Merging upstream version 1.44.3.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

74 files changed, 25015 insertions, 0 deletions

diff --git a/fluent-bit/lib/ctraces/.github/actionlint-matcher.json b/fluent-bit/lib/ctraces/.github/actionlint-matcher.json
new file mode 100644
index 000000000..7b1ba251e
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.github/actionlint-matcher.json
@@ -0,0 +1,17 @@
+{
+    "problemMatcher": [
+      {
+        "owner": "actionlint",
+        "pattern": [
+          {
+            "regexp": "^(?:\\x1b\\[\\d+m)?(.+?)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*: (?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)* \\[(.+?)\\]$",
+            "file": 1,
+            "line": 2,
+            "column": 3,
+            "message": 4,
+            "code": 5
+          }
+        ]
+      }
+    ]
+  }
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/.github/dependabot.yml b/fluent-bit/lib/ctraces/.github/dependabot.yml
new file mode 100644
index 000000000..12f9b4a0b
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.github/dependabot.yml
@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/.github/workflows/build.yaml b/fluent-bit/lib/ctraces/.github/workflows/build.yaml
new file mode 100644
index 000000000..45710f6c4
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.github/workflows/build.yaml
@@ -0,0 +1,145 @@
+name: Build PR(s) and master branch.
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+    types: [opened, reopened, synchronize]
+jobs:
+  build-windows:
+    name: Build sources on amd64 for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, windows-2019]
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Build on ${{ matrix.os }} with vs-2019
+        run: |
+          .\scripts\win_build.bat
+
+      - name: Run unit tests.
+        run: |
+          ctest --rerun-failed --output-on-failure -C Debug --test-dir .\tests\
+
+  build-centos:
+    name: CentOS 7 build to confirm no issues once used downstream
+    runs-on: ubuntu-latest
+    container: centos:7
+    permissions:
+      contents: none
+    steps:
+      - name: Set up base image dependencies
+        run: |
+          yum -y update && \
+          yum install -y ca-certificates cmake curl-devel gcc gcc-c++ git make wget && \
+          wget http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm && \
+          rpm -ivh epel-release-latest-7.noarch.rpm && \
+          yum install -y cmake3
+        shell: bash
+
+      - name: Clone repo with submodules (1.8.3 version of Git)
+        run: |
+          git clone --recursive https://github.com/calyptia/ctraces.git
+        shell: bash
+
+      - name: Run compilation
+        run: |
+          cmake3 -DCTR_TESTS=on -DCTR_DEV=on .
+          make
+        shell: bash
+        working-directory: ctraces
+
+  build-unix-arm64:
+    name: Build sources on arm64 for ${{ matrix.os }} - ${{ matrix.compiler }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        compiler: [ gcc, clang ]
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Build on ${{ matrix.os }} with ${{ matrix.compiler }}
+        uses: uraimo/run-on-arch-action@v2.2.1
+        with:
+          arch: aarch64
+          distro: ubuntu20.04
+          run: |
+            apt-get update && \
+            apt-get install -y --no-install-recommends \
+            build-essential \
+            cmake \
+            file \
+            make
+            export CC=${{ env.compiler }}
+            cmake -DCTR_TESTS=On .
+            make all
+            CTEST_OUTPUT_ON_FAILURE=1 make test
+        env:
+          CC: ${{ matrix.compiler }}
+
+  build-unix-amd64:
+    name: Build sources on amd64 for ${{ matrix.os }} - ${{ matrix.compiler }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        compiler: [ gcc, clang ]
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Build on ${{ matrix.os }} with ${{ matrix.compiler }}
+        run: |
+          echo "CC = $CC, CXX = $CXX"
+          cmake -DCTR_TESTS=On .
+          make all
+          CTEST_OUTPUT_ON_FAILURE=1 make test
+        shell: bash
+        env:
+          CC: ${{ matrix.compiler }}
+
+  build-analysis-tests:
+    name: Build with various code analysis tools
+    strategy:
+      fail-fast: false
+      matrix:
+        preset:
+          - clang-sanitize-address
+          - clang-sanitize-memory
+          - clang-sanitize-undefined
+          - clang-sanitize-dataflow
+          - clang-sanitize-safe-stack
+          - valgrind
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - uses: docker://lpenz/ghaction-cmake:0.19
+        with:
+          preset: ${{ matrix.preset }}
+          # dependencies_debian: ''
+          cmakeflags: '-DCTR_TESTS=On -DCMT_DEV=on .'
+          build_command: make all
diff --git a/fluent-bit/lib/ctraces/.github/workflows/lint.yaml b/fluent-bit/lib/ctraces/.github/workflows/lint.yaml
new file mode 100644
index 000000000..46471fa5b
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.github/workflows/lint.yaml
@@ -0,0 +1,32 @@
+name: Lint PRs
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+
+  shellcheck-pr:
+    runs-on: ubuntu-latest
+    name: PR - Shellcheck
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ludeeus/action-shellcheck@master
+
+  actionlint-pr:
+    runs-on: ubuntu-latest
+    name: PR - Actionlint
+    steps:
+      - uses: actions/checkout@v3
+      - run: |
+          echo "::add-matcher::.github/actionlint-matcher.json"
+          bash <(curl https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash)
+          ./actionlint -color -shellcheck=
+        shell: bash
+
+  docslint-pr:
+    runs-on: ubuntu-latest
+    name: PR - Markdownlint
+    steps:
+      - uses: actions/checkout@v3
+      - name: Run markdownlint
+        uses: actionshub/markdownlint@2.0.2
diff --git a/fluent-bit/lib/ctraces/.github/workflows/packages.yaml b/fluent-bit/lib/ctraces/.github/workflows/packages.yaml
new file mode 100644
index 000000000..37ca6833f
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.github/workflows/packages.yaml
@@ -0,0 +1,107 @@
+name: Build packages for master or a tagged release
+
+on:
+  push:
+    branches:
+      - master
+    # Any tag starting with 'v'
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  build-distro-packages-arm64:
+    runs-on: ubuntu-latest
+    name: build arm64 packages
+    strategy:
+      fail-fast: false
+      matrix:
+        format: [ rpm, deb ]
+    steps:
+      - uses: actions/checkout@v3
+        with:
+            submodules: true
+
+      - uses: uraimo/run-on-arch-action@v2.2.1
+        name: Build the ${{matrix.format}} packages
+        with:
+          arch: aarch64
+          distro: ubuntu20.04
+          run: |
+            apt-get update && \
+            apt-get install -y --no-install-recommends \
+            build-essential \
+            cmake \
+            file \
+            rpm \
+            make 
+            cmake .
+            echo ${{ matrix.format }} | awk '{print toupper($0)}' | xargs -I{} cpack -G {}
+
+      - name: Store the master package artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.format }}-arm64
+          path: |
+            ./*.${{matrix.format}}
+
+  build-distro-packages-amd64:
+    name: build amd64 packages
+    strategy:
+      fail-fast: false
+      matrix:
+        format: [ rpm, deb ]
+    runs-on: [ ubuntu-latest ]
+    steps:
+      - uses: actions/checkout@v3
+        with:
+            submodules: true
+
+      - name: Build the ${{matrix.format}} packages
+        run:  |
+          cmake .
+          echo ${{ matrix.format }} | awk '{print toupper($0)}' | xargs -I{} cpack -G {}
+
+      - name: Store the master package artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.format }}-amd64
+          path: |
+            ./*.${{matrix.format}}
+
+  release:
+    name: Create release and upload packages
+    needs:
+      - build-distro-packages-amd64
+      - build-distro-packages-arm64
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download all artefacts
+        uses: actions/download-artifact@v3
+        with:
+          path: artifacts/
+
+      - name: Display structure of downloaded files
+        run: ls -R
+        working-directory: artifacts
+        shell: bash
+
+      - name: Unstable release on push to master to make it easier to download
+        uses: pyTooling/Actions/releaser@r0
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: 'unstable'
+          rm: true
+          files: |
+            artifacts/**/*
+
+      - name: Release on tag
+        uses: softprops/action-gh-release@v1
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          generate_release_notes: true
+          files: |
+            artifacts/**/*
diff --git a/fluent-bit/lib/ctraces/.gitignore b/fluent-bit/lib/ctraces/.gitignore
new file mode 100644
index 000000000..580a8a3e2
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.gitignore
@@ -0,0 +1,3 @@
+build/*
+include/ctraces/ctr_info.h
+include/ctraces/ctr_version.h
diff --git a/fluent-bit/lib/ctraces/.gitmodules b/fluent-bit/lib/ctraces/.gitmodules
new file mode 100644
index 000000000..3ae54b77c
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "lib/cfl"]
+	path = lib/cfl
+	url = https://github.com/fluent/cfl
+[submodule "lib/fluent-otel-proto"]
+	path = lib/fluent-otel-proto
+	url = https://github.com/fluent/fluent-otel-proto
diff --git a/fluent-bit/lib/ctraces/.mdlrc b/fluent-bit/lib/ctraces/.mdlrc
new file mode 100644
index 000000000..406517849
--- /dev/null
+++ b/fluent-bit/lib/ctraces/.mdlrc
@@ -0,0 +1 @@
+style "#{File.dirname(__FILE__)}/markdownlint.rb"
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/CMakeLists.txt b/fluent-bit/lib/ctraces/CMakeLists.txt
new file mode 100644
index 000000000..08e1b6d29
--- /dev/null
+++ b/fluent-bit/lib/ctraces/CMakeLists.txt
@@ -0,0 +1,349 @@
+cmake_minimum_required(VERSION 3.0)
+project(ctraces C)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Include helpers
+include(cmake/macros.cmake)
+include(CheckCSourceCompiles)
+include(GNUInstallDirs)
+
+# Define macro to identify Windows system (without Cygwin)
+if(CMAKE_SYSTEM_NAME MATCHES "Windows")
+  set(CTR_SYSTEM_WINDOWS On)
+  add_definitions(-DCTR_SYSTEM_WINDOWS)
+endif()
+
+# Define macro to identify macOS system
+if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  set(CTR_SYSTEM_MACOS On)
+  add_definitions(-DCTR_SYSTEM_MACOS)
+endif()
+
+if(NOT MSVC)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
+endif()
+
+# CTraces Version
+set(CTR_VERSION_MAJOR  0)
+set(CTR_VERSION_MINOR  3)
+set(CTR_VERSION_PATCH  1)
+set(CTR_VERSION_STR "${CTR_VERSION_MAJOR}.${CTR_VERSION_MINOR}.${CTR_VERSION_PATCH}")
+
+# Define __FILENAME__ consistently across Operating Systems
+if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__FILENAME__='\"$(subst ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")
+else()
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__FILENAME__=__FILE__")
+endif()
+
+# Configuration options
+option(CTR_DEV             "Enable development mode"                   No)
+option(CTR_TESTS           "Enable unit testing"                       No)
+option(CTR_EXAMPLES        "Build example binaries"                    No)
+option(CTR_INSTALL_TARGETS "Enable subdirectory library installations" Yes)
+
+if(CTR_DEV)
+  set(CTR_TESTS        Yes)
+  set(CTR_EXAMPLES     Yes)
+  set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+# Bundled libraries
+include(cmake/libraries.cmake)
+include(cmake/headers.cmake)
+
+# Include headers and dependency headers
+include_directories(
+  src
+  include
+  lib/monkey/include
+  )
+
+# timespec_get() support
+check_c_source_compiles("
+  #include <time.h>
+  int main() {
+     struct tm tm;
+     return timespec_get(&tm, TIME_UTC);
+  }" CTR_HAVE_TIMESPEC_GET)
+if(CTR_HAVE_TIMESPEC_GET)
+  CTR_DEFINITION(CTR_HAVE_TIMESPEC_GET)
+endif()
+
+# gmtime_r() support
+check_c_source_compiles("
+  #include <time.h>
+  int main() {
+     struct tm tm;
+     struct timespec tms;
+     return gmtime_r(&tms.tv_sec, &tm);
+  }" CTR_HAVE_GMTIME_R)
+if(CTR_HAVE_GMTIME_R)
+  CTR_DEFINITION(CTR_HAVE_GMTIME_R)
+endif()
+
+# gmtime_s() support
+check_c_source_compiles("
+  #include <time.h>
+  int main() {
+     struct tm tm;
+     struct timespec tms;
+     return gmtime_s(&tm, &tms.tv_sec);
+  }" CTR_HAVE_GMTIME_S)
+if(CTR_HAVE_GMTIME_S)
+  CTR_DEFINITION(CTR_HAVE_GMTIME_S)
+endif()
+
+# clock_get_time() support for macOS.
+check_c_source_compiles("
+  #include <mach/clock.h>
+  #include <mach/mach.h>
+  int main() {
+      clock_serv_t cclock;
+      mach_timespec_t mts;
+      host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+      clock_get_time(cclock, &mts);
+      return mach_port_deallocate(mach_task_self(), cclock);
+  }" CTR_HAVE_CLOCK_GET_TIME)
+if(CTR_HAVE_CLOCK_GET_TIME)
+  CTR_DEFINITION(CTR_HAVE_CLOCK_GET_TIME)
+endif()
+
+# getrandom()
+check_c_source_compiles("
+  #include <sys/random.h>
+  int main() {
+      unsigned int tmp;
+      getrandom(tmp, sizeof(tmp), GRND_NONBLOCK);
+      return 0;
+  }" CTR_HAVE_GETRANDOM)
+if(CTR_HAVE_GETRANDOM)
+  CTR_DEFINITION(CTR_HAVE_GETRANDOM)
+endif()
+
+
+# FIXME: MessagePack support
+check_c_source_compiles("
+  #include \"../../../lib/msgpack-c/include/msgpack.h\"
+  int main() {
+     msgpack_packer pck;
+     msgpack_sbuffer sbuf;
+     return 0;
+  }" CTR_HAVE_MSGPACK)
+
+# Check if 'C Floppy' library is available in the environment, if not,
+# we will try to build a local copy at a later stage
+check_c_source_compiles("
+  #include <cfl/cfl_found.h>
+  int main() {
+     return cfl_found();
+  }" CTR_HAVE_CFL)
+if(CTR_HAVE_CFL)
+  CTR_DEFINITION(CTR_HAVE_CFL)
+endif()
+
+# Check if fluent-otel-proto library is available in the environment, if not,
+# we will try to build a local copy at a later stage
+check_c_source_compiles("
+  #include <fluent-otel-proto/fluent-otel_found.h>
+  int main() {
+     return fluent_otel_found();
+  }" CTR_HAVE_FLUENT_OTEL_PROTO)
+if(CTR_HAVE_FLUENT_OTEL_PROTO)
+  CTR_DEFINITION(CTR_HAVE_FLUENT_OTEL_PROTO)
+endif()
+
+configure_file(
+  "${PROJECT_SOURCE_DIR}/include/ctraces/ctr_info.h.in"
+  "${PROJECT_SOURCE_DIR}/include/ctraces/ctr_info.h"
+  )
+
+configure_file(
+  "${PROJECT_SOURCE_DIR}/include/ctraces/ctr_version.h.in"
+  "${PROJECT_SOURCE_DIR}/include/ctraces/ctr_version.h"
+  )
+
+# Installation Directories
+# ========================
+if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(CTR_INSTALL_LIBDIR "lib")
+  set(CTR_INSTALL_INCLUDEDIR "include")
+else()
+  set(CTR_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  set(CTR_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include")
+endif()
+
+# mpack
+if(NOT TARGET mpack-static)
+  include_directories(lib/mpack/src/)
+  add_subdirectory(lib/mpack EXCLUDE_FROM_ALL)
+
+  if (CTR_INSTALL_TARGETS)
+    install(TARGETS mpack-static
+      RUNTIME DESTINATION ${CTR_INSTALL_BINDIR}
+      LIBRARY DESTINATION ${CTR_INSTALL_LIBDIR}
+      ARCHIVE DESTINATION ${CTR_INSTALL_LIBDIR}
+      COMPONENT library)
+
+    install(FILES lib/mpack/src/mpack/mpack.h
+      DESTINATION ${CTR_INSTALL_INCLUDEDIR}/mpack
+      COMPONENT headers
+      PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
+  endif()
+endif()
+
+# C Floppy
+if (NOT CTR_HAVE_CFL)
+  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/${CTR_PATH_LIB_CFL}/include)
+  add_subdirectory(lib/cfl)
+  CTR_DEFINITION(CTR_HAVE_CFL)
+  CTR_DEFINITION(CTR_HAVE_CFL_INTERNAL)
+endif()
+
+# fluent-otel-proto
+if (NOT CTR_HAVE_FLUENT_OTEL_PROTO)
+  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/${CTR_PATH_LIB_FLUENT_OTEL_PROTO}/include)
+  CTR_OPTION(FLUENT_PROTO_EXAMPLES "off")
+  add_subdirectory(lib/fluent-otel-proto)
+  CTR_DEFINITION(CTR_HAVE_FLUENT_OTEL_PROTO)
+  CTR_DEFINITION(CTR_HAVE_FLUENT_OTEL_PROTO_INTERNAL)
+endif()
+
+# Source code
+add_subdirectory(include)
+add_subdirectory(src)
+
+# Examples
+if (CTR_EXAMPLES)
+  add_subdirectory(examples)
+endif()
+
+# Tests
+if(CTR_TESTS)
+  enable_testing()
+  add_subdirectory(tests)
+endif()
+
+# Output paths
+set(CTRACES_ROOT "${CMAKE_CURRENT_SOURCE_DIR}")
+set(CTRACES_BUILD_DIR "${CTRACES_ROOT}/build")
+
+# Installer Generation (Cpack)
+# ============================
+
+set(CPACK_PACKAGE_VERSION ${CTR_VERSION_STR})
+set(CPACK_PACKAGE_NAME "ctraces")
+set(CPACK_PACKAGE_RELEASE 1)
+set(CPACK_PACKAGE_CONTACT "Eduardo Silva <eduardo@calyptia.com>")
+set(CPACK_PACKAGE_VENDOR "Calyptia")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
+set(CPACK_PACKAGING_INSTALL_PREFIX "/")
+
+set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_PACKAGE_RELEASE}.${CMAKE_SYSTEM_PROCESSOR}")
+
+if(CTR_SYSTEM_WINDOWS)
+  set(CPACK_GENERATOR "ZIP")
+
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-win64")
+  else()
+    set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-win32")
+  endif()
+endif()
+
+
+# Enable components
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_productbuild_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENTS_ALL ${CPACK_COMPONENTS_ALL} binary library headers)
+set(CPACK_COMPONENTS_GROUPING "ONE_PER_GROUP")
+
+set(CPACK_COMPONENT_BINARY_GROUP "RUNTIME")
+set(CPACK_COMPONENT_LIBRARY_GROUP "RUNTIME")
+
+# Debian package setup and name sanitizer
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+
+find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")
+if(DPKG_PROGRAM)
+  execute_process(
+    COMMAND ${DPKG_PROGRAM} --print-architecture
+    OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+  set(CPACK_DEBIAN_HEADERS_FILE_NAME "${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}-headers.deb")
+  set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
+  set(CPACK_DEBIAN_RUNTIME_FILE_NAME "${CPACK_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb")
+  set(CPACK_DEBIAN_RUNTIME_PACKAGE_CONTROL_EXTRA
+    ${CMAKE_CURRENT_SOURCE_DIR}/debian/conffiles
+    )
+endif()
+
+# RPM Generation information
+set(CPACK_RPM_PACKAGE_GROUP "System Environment/Daemons")
+set(CPACK_RPM_PACKAGE_LICENSE "Apache v2.0")
+set(CPACK_RPM_PACKAGE_RELEASE ${CPACK_PACKAGE_RELEASE})
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/cpack/description")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "C Traces Library")
+set(CPACK_RPM_SPEC_MORE_DEFINE "%define ignore \#")
+set(CPACK_RPM_USER_FILELIST
+  "%ignore /lib"
+  "%ignore /lib64"
+  "%ignore /lib64/pkgconfig"
+  "%ignore /usr/local"
+  "%ignore /usr/local/bin")
+
+set(CPACK_RPM_PACKAGE_AUTOREQ ON)
+set(CPACK_RPM_RUNTIME_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
+set(CPACK_RPM_HEADERS_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_PACKAGE_RELEASE}.${CMAKE_SYSTEM_PROCESSOR}-headers.rpm")
+set(CPACK_RPM_RUNTIME_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_PACKAGE_RELEASE}.${CMAKE_SYSTEM_PROCESSOR}.rpm")
+
+# CPack: DEB
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+
+# CPack: Windows System
+if(CPACK_GENERATOR MATCHES "ZIP")
+  set(CPACK_MONOLITHIC_INSTALL 1)
+  set(CPACK_PACKAGE_INSTALL_DIRECTORY "ctraces")
+endif()
+
+# CPack: macOS w/ productbuild
+if(CTR_SYSTEM_MACOS)
+  # Determine the platform suffix
+  execute_process(
+    COMMAND uname -m
+    RESULT_VARIABLE UNAME_M_RESULT
+    OUTPUT_VARIABLE UNAME_ARCH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+  if (UNAME_M_RESULT EQUAL 0 AND UNAME_ARCH STREQUAL "arm64")
+    set(CMETRICS_PKG ${CTRACES_BUILD_DIR}/${CPACK_PACKAGE_NAME}-${CTR_VERSION_STR}-apple)
+  elseif(UNAME_M_RESULT EQUAL 0 AND UNAME_ARCH STREQUAL "x86_64")
+    set(CMETRICS_PKG ${CTRACES_BUILD_DIR}/${CPACK_PACKAGE_NAME}-${CTR_VERSION_STR}-intel)
+  else()
+    set(CMETRICS_PKG ${CTRACES_BUILD_DIR}/${CPACK_PACKAGE_NAME}-${CTR_VERSION_STR}-${UNAME_ARCH})
+  endif()
+
+  if (CPACK_GENERATOR MATCHES "productbuild")
+    set(CPACK_SET_DESTDIR "ON")
+    configure_file(cpack/macos/welcome.txt.cmakein ${CTRACES_BUILD_DIR}/welcome.txt)
+    configure_file(LICENSE ${CTRACES_BUILD_DIR}/LICENSE.txt)
+    find_program(CONVERTER textutil)
+    if (NOT CONVERTER)
+      message(FATAL_ERROR "textutil not found.")
+    endif()
+    if (CONVERTER)
+      execute_process(COMMAND ${CONVERTER} -convert html "${CMAKE_SOURCE_DIR}/README.md" -output "${CTRACES_BUILD_DIR}/README.html")
+    endif()
+    set(CPACK_PACKAGE_FILE_NAME "${CMETRICS_PKG}")
+    set(CPACK_RESOURCE_FILE_WELCOME ${CTRACES_BUILD_DIR}/welcome.txt)
+    set(CPACK_RESOURCE_FILE_LICENSE ${CTRACES_BUILD_DIR}/LICENSE.txt)
+    set(CPACK_RESOURCE_FILE_README ${CTRACES_BUILD_DIR}/README.html)
+    set(CPACK_PRODUCTBUILD_IDENTIFIER "com.calyptia.${CPACK_PACKAGE_NAME}")
+  endif()
+endif()
+
+include(CPack)
diff --git a/fluent-bit/lib/ctraces/LICENSE b/fluent-bit/lib/ctraces/LICENSE
new file mode 100644
index 000000000..f433b1a53
--- /dev/null
+++ b/fluent-bit/lib/ctraces/LICENSE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/fluent-bit/lib/ctraces/README.md b/fluent-bit/lib/ctraces/README.md
new file mode 100644
index 000000000..7caca25bb
--- /dev/null
+++ b/fluent-bit/lib/ctraces/README.md
@@ -0,0 +1,42 @@
+# CTraces
+
+The [CTraces](https://github.com/calyptia/ctraces) project is a tiny library to create and maintain Traces contexts and provide utilities for data manipulation, including encoding/decoding for compatibility with OpenTelemetry and other formats.
+
+This project is a core library for [Fluent Bit](https://fluentbit.io): agent and aggregator for Observability.
+
+## Build
+
+Clone the repository:
+
+```shell
+git clone https://github.com/calyptia/ctraces
+```
+
+Get into the project directory and retrieve submodules:
+
+```shell
+cd ctraces
+git submodule update --init --recursive --remote
+```
+
+Compile:
+
+```shell
+cd build/
+cmake -DCTR_DEV=on ../
+make
+```
+
+> CTR_DEV flag enables debugging mode, examples and the unit tests
+
+## Usage
+
+In the [examples](examples/) directory, you will find a _simple_ example that describes how to use the API.
+
+## License
+
+This program is under the terms of the [Apache License v2.0](http://www.apache.org/licenses/LICENSE-2.0).
+
+## Authors
+
+[Calyptia Team](https://www.calyptia.com)
diff --git a/fluent-bit/lib/ctraces/appveyor.yml b/fluent-bit/lib/ctraces/appveyor.yml
new file mode 100644
index 000000000..5e244a601
--- /dev/null
+++ b/fluent-bit/lib/ctraces/appveyor.yml
@@ -0,0 +1,26 @@
+version: v1-winbuild-{build}
+
+image: Visual Studio 2019
+
+platform:
+  - Win32
+  - x64
+
+environment:
+  vspath: 'C:\Program Files (x86)\Microsoft Visual Studio\2019\Community'
+
+configuration:
+  - Release
+  
+skip_commits:
+  message: /workflows/
+  files:
+    - '.github/**'
+
+before_build:
+  - if %PLATFORM%==Win32 call "%vspath%\VC\Auxiliary\Build\vcvars32.bat"
+  - if %PLATFORM%==x64   call "%vspatH%\VC\Auxiliary\Build\vcvars64.bat"
+  
+build_script:
+  - .\scripts\win_build.bat
+  - ctest -C Debug --test-dir .\tests\
diff --git a/fluent-bit/lib/ctraces/cmake/headers.cmake b/fluent-bit/lib/ctraces/cmake/headers.cmake
new file mode 100644
index 000000000..3a7eb09fb
--- /dev/null
+++ b/fluent-bit/lib/ctraces/cmake/headers.cmake
@@ -0,0 +1,3 @@
+include_directories(${PROJECT_SOURCE_DIR}/lib/fluent-otel-proto/include
+					${PROJECT_SOURCE_DIR}/lib/fluent-otel-proto/proto_c
+					)
diff --git a/fluent-bit/lib/ctraces/cmake/libraries.cmake b/fluent-bit/lib/ctraces/cmake/libraries.cmake
new file mode 100644
index 000000000..5e744634f
--- /dev/null
+++ b/fluent-bit/lib/ctraces/cmake/libraries.cmake
@@ -0,0 +1,3 @@
+# List of bundled libraries
+set(CTR_PATH_LIB_CFL               "lib/cfl")
+set(CTR_PATH_LIB_FLUENT_OTEL_PROTO "lib/fluent-otel-proto")
diff --git a/fluent-bit/lib/ctraces/cmake/macros.cmake b/fluent-bit/lib/ctraces/cmake/macros.cmake
new file mode 100644
index 000000000..877ab14cb
--- /dev/null
+++ b/fluent-bit/lib/ctraces/cmake/macros.cmake
@@ -0,0 +1,10 @@
+# Macro to set definitions
+macro(CTR_DEFINITION var)
+  add_definitions(-D${var})
+  set(CTR_BUILD_FLAGS "${CTR_BUILD_FLAGS}#ifndef ${var}\n#define ${var}\n#endif\n")
+  set(CTR_INFO_FLAGS "${CTR_INFO_FLAGS} ${var}")
+endmacro()
+
+macro(CTR_OPTION option value)
+  set(${option} ${value} CACHE INTERNAL "" FORCE)
+endmacro()
diff --git a/fluent-bit/lib/ctraces/cpack/description b/fluent-bit/lib/ctraces/cpack/description
new file mode 100644
index 000000000..b35f43fab
--- /dev/null
+++ b/fluent-bit/lib/ctraces/cpack/description
@@ -0,0 +1 @@
+A standalone library to create and manipulate traces in C.
diff --git a/fluent-bit/lib/ctraces/cpack/macos/welcome.txt.cmakein b/fluent-bit/lib/ctraces/cpack/macos/welcome.txt.cmakein
new file mode 100644
index 000000000..8623042b2
--- /dev/null
+++ b/fluent-bit/lib/ctraces/cpack/macos/welcome.txt.cmakein
@@ -0,0 +1,7 @@
+This will install @CPACK_PACKAGE_NAME@ on your Mac.
+
+--------------------------------------------------
+
+Thank you for trying @CPACK_PACKAGE_NAME@! Have a fantastic day!
+
+You can use @CPACK_PACKAGE_NAME@ as metrics library on your system.
diff --git a/fluent-bit/lib/ctraces/examples/CMakeLists.txt b/fluent-bit/lib/ctraces/examples/CMakeLists.txt
new file mode 100644
index 000000000..4c65c5b6e
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/CMakeLists.txt
@@ -0,0 +1,24 @@
+# example: simple C api usage
+set(src
+	simple-c-api.c
+	)
+
+add_executable(ctraces-simple-c-api ${src})
+target_link_libraries(ctraces-simple-c-api ctraces-static fluent-otel-proto)
+
+# example: opentelemetry decoder -> ctrace
+set(src
+	otlp-decoder.c
+	)
+
+add_executable(ctraces-otlp-decoder ${src})
+target_link_libraries(ctraces-otlp-decoder ctraces-static)
+configure_file(sample_trace.bin sample_trace.bin COPYONLY)
+
+# example: opentelemetry encoder
+set(src
+	otlp-encoder/otlp-encoder.c
+	)
+
+add_executable(ctraces-otlp-encoder ${src})
+target_link_libraries(ctraces-otlp-encoder ctraces-static curl)
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/examples/otlp-decoder.c b/fluent-bit/lib/ctraces/examples/otlp-decoder.c
new file mode 100644
index 000000000..2b3d390da
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/otlp-decoder.c
@@ -0,0 +1,61 @@
+#include <ctraces/ctraces.h>
+#include <fluent-otel-proto/fluent-otel.h>
+
+int main()
+{
+    FILE *fp;
+    struct ctrace *ctr;
+
+    char *text;
+    char *buf;
+    int result;
+    int bufsize;
+    size_t offset;
+    size_t newLen;
+
+    offset = 0;
+    bufsize = 0;
+    buf = NULL;
+
+    fp = fopen("examples/sample_trace.bin", "rb");
+
+    if (fp != NULL) {
+        if (fseek(fp, 0L, SEEK_END) == 0) {
+
+            bufsize = ftell(fp);
+            if (bufsize == -1)
+            {
+                printf("error in reading file size");
+            }
+
+            buf = malloc(sizeof(char) * (bufsize + 1));
+
+            if (fseek(fp, 0L, SEEK_SET) != 0) {
+                printf("seek error");
+            }
+
+            newLen = fread(buf, sizeof(char), bufsize, fp);
+            if (ferror(fp) != 0) {
+                fputs("Error reading file", stderr);
+            }
+            else {
+                buf[newLen++] = '\0';
+            }
+        }
+        fclose(fp);
+    }
+
+    result = ctr_decode_opentelemetry_create(&ctr, buf, bufsize, &offset);
+    if (result == -1) {
+        printf("Unable to decode trace sample");
+    }
+
+    text = ctr_encode_text_create(ctr);
+    printf("%s\n", text);
+    ctr_encode_text_destroy(text);
+
+    ctr_destroy(ctr);
+    free(buf);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/examples/otlp-encoder/README.md b/fluent-bit/lib/ctraces/examples/otlp-encoder/README.md
new file mode 100644
index 000000000..78e65aca3
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/otlp-encoder/README.md
@@ -0,0 +1,26 @@
+# Instructions to run
+
+After building the project with `-CTR_DEV=on`, the example can be found at `build/examples/ctraces-otlp-encoder`
+
+The example encodes a ctraces context to a buffer and sends it to a locally running instance of the [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/). After setting up the collector locally by [following the instructions from their docs](https://opentelemetry.io/docs/collector/getting-started/), you can start the collector with the following config file:
+
+```yaml
+receivers:
+  otlp:
+    protocols:
+      http:
+        endpoint: "0.0.0.0:4318"
+
+exporters:
+  logging:
+    loglevel: debug
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      exporters: [logging]
+```
+
+Now you can run the example and see the trace data logged by the collector instance.
+
diff --git a/fluent-bit/lib/ctraces/examples/otlp-encoder/otlp-encoder.c b/fluent-bit/lib/ctraces/examples/otlp-encoder/otlp-encoder.c
new file mode 100644
index 000000000..00b984a40
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/otlp-encoder/otlp-encoder.c
@@ -0,0 +1,186 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+#include <ctraces/ctraces.h>
+#include <unistd.h>
+#include <curl/curl.h>
+
+int main()
+{
+    cfl_sds_t buf;
+    struct ctrace *ctx;
+    struct ctrace_opts opts;
+    struct ctrace_span *span_root;
+    struct ctrace_span *span_child;
+    struct ctrace_span_event *event;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_resource *resource;
+    struct ctrace_scope_span *scope_span;
+    struct ctrace_instrumentation_scope *instrumentation_scope;
+    struct ctrace_link *link;
+    struct ctrace_id *span_id;
+    struct ctrace_id *trace_id;
+    struct cfl_array *array;
+    struct cfl_array *sub_array;
+    struct cfl_kvlist *kv;
+
+    struct curl_slist *headers;
+    CURL *curl;
+    CURLcode res;
+
+    /*
+     * create an options context: this is used to initialize a CTrace context only,
+     * it's not mandatory and you can pass a NULL instead on context creation.
+     *
+     * note: not used.
+     */
+    ctr_opts_init(&opts);
+
+    /* ctrace context */
+    ctx = ctr_create(&opts);
+    if (!ctx) {
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* resource span */
+    resource_span = ctr_resource_span_create(ctx);
+    ctr_resource_span_set_schema_url(resource_span, "https://ctraces/resource_span_schema_url");
+
+    /* create a 'resource' for the 'resource span' in question */
+    resource = ctr_resource_span_get_resource(resource_span);
+    ctr_resource_set_dropped_attr_count(resource, 5);
+
+    /* scope span */
+    scope_span = ctr_scope_span_create(resource_span);
+    ctr_scope_span_set_schema_url(scope_span, "https://ctraces/scope_span_schema_url");
+
+    /* create an optional instrumentation scope */
+    instrumentation_scope = ctr_instrumentation_scope_create("ctrace", "a.b.c", 3, NULL);
+    ctr_scope_span_set_instrumentation_scope(scope_span, instrumentation_scope);
+
+    /* generate a random trace_id */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+
+    /* generate a random ID for the new span */
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+
+    /* Create a root span */
+    span_root = ctr_span_create(ctx, scope_span, "main", NULL);
+    if (!span_root) {
+        ctr_destroy(ctx);
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* assign the random ID */
+    ctr_span_set_span_id_with_cid(span_root, span_id);
+
+    /* set random trace_id */
+    ctr_span_set_trace_id_with_cid(span_root, trace_id);
+
+    /* add some attributes to the span */
+    ctr_span_set_attribute_string(span_root, "agent", "Fluent Bit");
+    ctr_span_set_attribute_int64(span_root, "year", 2022);
+    ctr_span_set_attribute_bool(span_root, "open_source", CTR_TRUE);
+    ctr_span_set_attribute_double(span_root, "temperature", 25.5);
+
+    /* pack an array: create an array context by using the CFL api */
+    array = cfl_array_create(4);
+    cfl_array_append_string(array, "first");
+    cfl_array_append_double(array, 2.0);
+    cfl_array_append_bool(array, CFL_FALSE);
+
+    sub_array = cfl_array_create(3);
+    cfl_array_append_double(sub_array, 3.1);
+    cfl_array_append_double(sub_array, 5.2);
+    cfl_array_append_double(sub_array, 6.3);
+    cfl_array_append_array(array, sub_array);
+
+    /* add array to the attribute list */
+    ctr_span_set_attribute_array(span_root, "my_array", array);
+
+    /* event: add one event and set attributes to it */
+    event = ctr_span_event_add(span_root, "connect to remote server");
+
+    ctr_span_event_set_attribute_string(event, "syscall 1", "open()");
+    ctr_span_event_set_attribute_string(event, "syscall 2", "connect()");
+    ctr_span_event_set_attribute_string(event, "syscall 3", "write()");
+
+    /* add a key/value pair list */
+    kv = cfl_kvlist_create(1);
+    cfl_kvlist_insert_string(kv, "language", "c");
+
+    ctr_span_set_attribute_kvlist(span_root, "my-list", kv);
+
+    /* create a child span */
+    span_child = ctr_span_create(ctx, scope_span, "do-work", span_root);
+    if (!span_child) {
+        ctr_destroy(ctx);
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* set trace_id */
+    ctr_span_set_trace_id_with_cid(span_child, trace_id);
+
+    /* use span_root ID as parent_span_id */
+    ctr_span_set_parent_span_id_with_cid(span_child, span_id);
+
+    /* delete old span id and generate a new one */
+    ctr_id_destroy(span_id);
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    ctr_span_set_span_id_with_cid(span_child, span_id);
+
+    /* destroy the IDs since is not longer needed */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    /* change span kind to client */
+    ctr_span_kind_set(span_child, CTRACE_SPAN_CLIENT);
+
+    /* create a Link (no valid IDs of course) */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+
+    link = ctr_link_create_with_cid(span_child, trace_id, span_id);
+    ctr_link_set_trace_state(link, "aaabbbccc");
+    ctr_link_set_dropped_attr_count(link, 2);
+
+    /* delete IDs */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    /* Encode Trace as otlp buffer */
+    buf = ctr_encode_opentelemetry_create(ctx);
+    if (!buf) {
+        ctr_destroy(ctx);
+        ctr_encode_opentelemetry_destroy(buf);
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    curl = curl_easy_init();
+
+    if (curl){
+        headers = NULL;
+        headers = curl_slist_append(headers, "Content-Type: application/x-protobuf");
+        curl_easy_setopt(curl, CURLOPT_URL, "0.0.0.0:4318/v1/traces");
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, buf);
+        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, cfl_sds_len(buf));
+        res = curl_easy_perform(curl);
+        if(res != CURLE_OK)
+            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+        curl_easy_cleanup(curl);
+    }
+    curl_global_cleanup();
+
+    /* destroy the context */
+    ctr_destroy(ctx);
+    ctr_encode_opentelemetry_destroy(buf);
+
+    /* exit options (it release resources allocated) */
+    ctr_opts_exit(&opts);
+
+    return 0;
+}
diff --git a/fluent-bit/lib/ctraces/examples/sample_trace.bin b/fluent-bit/lib/ctraces/examples/sample_trace.bin
new file mode 100644
index 000000000..579a3300f
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/sample_trace.bin
diff --git a/fluent-bit/lib/ctraces/examples/simple-c-api.c b/fluent-bit/lib/ctraces/examples/simple-c-api.c
new file mode 100644
index 000000000..aeaeff120
--- /dev/null
+++ b/fluent-bit/lib/ctraces/examples/simple-c-api.c
@@ -0,0 +1,160 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+#include <ctraces/ctraces.h>
+#include <unistd.h>
+
+int main()
+{
+    char *text;
+    struct ctrace *ctx;
+    struct ctrace_opts opts;
+    struct ctrace_span *span_root;
+    struct ctrace_span *span_child;
+    struct ctrace_span_event *event;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_resource *resource;
+    struct ctrace_scope_span *scope_span;
+    struct ctrace_instrumentation_scope *instrumentation_scope;
+    struct ctrace_link *link;
+    struct ctrace_id *span_id;
+    struct ctrace_id *trace_id;
+    struct cfl_array *array;
+    struct cfl_array *sub_array;
+    struct cfl_kvlist *kv;
+
+    /*
+     * create an options context: this is used to initialize a CTrace context only,
+     * it's not mandatory and you can pass a NULL instead on context creation.
+     *
+     * note: not used.
+     */
+    ctr_opts_init(&opts);
+
+    /* ctrace context */
+    ctx = ctr_create(&opts);
+    if (!ctx) {
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* resource span */
+    resource_span = ctr_resource_span_create(ctx);
+    ctr_resource_span_set_schema_url(resource_span, "https://ctraces/resource_span_schema_url");
+
+    /* create a 'resource' for the 'resource span' in question */
+    resource = ctr_resource_span_get_resource(resource_span);
+    ctr_resource_set_dropped_attr_count(resource, 5);
+
+    /* scope span */
+    scope_span = ctr_scope_span_create(resource_span);
+    ctr_scope_span_set_schema_url(scope_span, "https://ctraces/scope_span_schema_url");
+
+    /* create an optional instrumentation scope */
+    instrumentation_scope = ctr_instrumentation_scope_create("ctrace", "a.b.c", 3, NULL);
+    ctr_scope_span_set_instrumentation_scope(scope_span, instrumentation_scope);
+
+    /* generate a random trace_id */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+
+    /* generate a random ID for the new span */
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+
+    /* Create a root span */
+    span_root = ctr_span_create(ctx, scope_span, "main", NULL);
+    if (!span_root) {
+        ctr_destroy(ctx);
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* assign the random ID */
+    ctr_span_set_span_id_with_cid(span_root, span_id);
+
+    /* set random trace_id */
+    ctr_span_set_trace_id_with_cid(span_root, trace_id);
+
+    /* add some attributes to the span */
+    ctr_span_set_attribute_string(span_root, "agent", "Fluent Bit");
+    ctr_span_set_attribute_int64(span_root, "year", 2022);
+    ctr_span_set_attribute_bool(span_root, "open_source", CTR_TRUE);
+    ctr_span_set_attribute_double(span_root, "temperature", 25.5);
+
+    /* pack an array: create an array context by using the CFL api */
+    array = cfl_array_create(4);
+    cfl_array_append_string(array, "first");
+    cfl_array_append_double(array, 2.0);
+    cfl_array_append_bool(array, CFL_FALSE);
+
+    sub_array = cfl_array_create(3);
+    cfl_array_append_double(sub_array, 3.1);
+    cfl_array_append_double(sub_array, 5.2);
+    cfl_array_append_double(sub_array, 6.3);
+    cfl_array_append_array(array, sub_array);
+
+    /* add array to the attribute list */
+    ctr_span_set_attribute_array(span_root, "my_array", array);
+
+    /* event: add one event and set attributes to it */
+    event = ctr_span_event_add(span_root, "connect to remote server");
+
+    ctr_span_event_set_attribute_string(event, "syscall 1", "open()");
+    ctr_span_event_set_attribute_string(event, "syscall 2", "connect()");
+    ctr_span_event_set_attribute_string(event, "syscall 3", "write()");
+
+    /* add a key/value pair list */
+    kv = cfl_kvlist_create(1);
+    cfl_kvlist_insert_string(kv, "language", "c");
+
+    ctr_span_set_attribute_kvlist(span_root, "my-list", kv);
+
+    /* create a child span */
+    span_child = ctr_span_create(ctx, scope_span, "do-work", span_root);
+    if (!span_child) {
+        ctr_destroy(ctx);
+        ctr_opts_exit(&opts);
+        exit(EXIT_FAILURE);
+    }
+
+    /* set trace_id */
+    ctr_span_set_trace_id_with_cid(span_child, trace_id);
+
+    /* use span_root ID as parent_span_id */
+    ctr_span_set_parent_span_id_with_cid(span_child, span_id);
+
+    /* delete old span id and generate a new one */
+    ctr_id_destroy(span_id);
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    ctr_span_set_span_id_with_cid(span_child, span_id);
+
+    /* destroy the IDs since is not longer needed */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    /* change span kind to client */
+    ctr_span_kind_set(span_child, CTRACE_SPAN_CLIENT);
+
+    /* create a Link (no valid IDs of course) */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+
+    link = ctr_link_create_with_cid(span_child, trace_id, span_id);
+    ctr_link_set_trace_state(link, "aaabbbccc");
+    ctr_link_set_dropped_attr_count(link, 2);
+
+    /* delete IDs */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    /* Encode Trace as a readable text */
+    text = ctr_encode_text_create(ctx);
+    printf("%s\n", text);
+    ctr_encode_text_destroy(text);
+
+    /* destroy the context */
+    ctr_destroy(ctx);
+
+    /* exit options (it release resources allocated) */
+    ctr_opts_exit(&opts);
+
+    return 0;
+}
diff --git a/fluent-bit/lib/ctraces/include/CMakeLists.txt b/fluent-bit/lib/ctraces/include/CMakeLists.txt
new file mode 100644
index 000000000..139c1d546
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/CMakeLists.txt
@@ -0,0 +1,5 @@
+file(GLOB ctracesHeaders "ctraces/*.h")
+install(FILES ${ctracesHeaders}
+    DESTINATION ${CTR_INSTALL_INCLUDEDIR}/ctraces
+    COMPONENT headers
+    PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_attributes.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_attributes.h
new file mode 100644
index 000000000..1b14a4f40
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_attributes.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_ATTRIBUTES_H
+#define CTR_ATTRIBUTES_H
+
+#include <ctraces/ctraces.h>
+
+#include <cfl/cfl.h>
+#include <cfl/cfl_kvlist.h>
+
+struct ctrace_attributes {
+    struct cfl_kvlist *kv;
+};
+
+struct ctrace_attributes *ctr_attributes_create();
+void ctr_attributes_destroy(struct ctrace_attributes *attr);
+int ctr_attributes_count(struct ctrace_attributes *attr);
+int ctr_attributes_set_string(struct ctrace_attributes *attr, char *key, char *value);
+int ctr_attributes_set_bool(struct ctrace_attributes *attr, char *key, int b);
+int ctr_attributes_set_int64(struct ctrace_attributes *attr, char *key, int64_t value);
+int ctr_attributes_set_double(struct ctrace_attributes *attr, char *key, double value);
+int ctr_attributes_set_array(struct ctrace_attributes *attr, char *key,
+                             struct cfl_array *value);
+int ctr_attributes_set_kvlist(struct ctrace_attributes *attr, char *key,
+                              struct cfl_kvlist *value);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_compat.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_compat.h
new file mode 100644
index 000000000..02293e814
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_compat.h
@@ -0,0 +1,39 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_COMPAT_H
+#define CTR_COMPAT_H
+
+#ifdef _WIN32
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <windows.h>
+
+#ifndef ssize_t
+typedef SSIZE_T ssize_t;
+#endif
+
+
+#else
+#include <unistd.h>
+
+#endif /* !_WIN32 */
+
+#endif /* !CTR_COMPAT_H */
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_msgpack.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_msgpack.h
new file mode 100644
index 000000000..e4689aadd
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_msgpack.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_DECODE_MSGPACK_H
+#define CTR_DECODE_MSGPACK_H
+
+#include <ctraces/ctraces.h>
+
+#define CTR_DECODE_MSGPACK_SUCCESS                (CTR_MPACK_SUCCESS)
+#define CTR_DECODE_MSGPACK_INVALID_ARGUMENT_ERROR (CTR_MPACK_INVALID_ARGUMENT_ERROR)
+#define CTR_DECODE_MSGPACK_INVALID_STATE          (CTR_MPACK_ERROR_CUTOFF + 1)
+#define CTR_DECODE_MSGPACK_ALLOCATION_ERROR       (CTR_MPACK_ERROR_CUTOFF + 2)
+#define CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR   (CTR_MPACK_ERROR_CUTOFF + 3)
+
+struct ctr_msgpack_decode_context {
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_scope_span    *scope_span;
+    struct ctrace_resource      *resource;
+    struct ctrace               *trace;
+    struct ctrace_span_event    *event;
+    struct ctrace_span          *span;
+    struct ctrace_link          *link;
+};
+
+int ctr_decode_msgpack_create(struct ctrace **out_context, char *in_buf, size_t in_size, size_t *offset);
+void ctr_decode_msgpack_destroy(struct ctrace *context);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_opentelemetry.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_opentelemetry.h
new file mode 100644
index 000000000..c1ba2c301
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_decode_opentelemetry.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_DECODE_OPENTELEMETRY_H
+#define CTR_DECODE_OPENTELEMETRY_H
+
+typedef enum {
+    CTR_OPENTELEMETRY_TYPE_ATTRIBUTE = 0,
+    CTR_OPENTELEMETRY_TYPE_ARRAY = 1,
+    CTR_OPENTELEMETRY_TYPE_KVLIST = 2,
+} opentelemetry_decode_value_type;
+
+struct opentelemetry_decode_value {
+    opentelemetry_decode_value_type type;
+    union {
+        struct ctrace_attributes *ctr_attr;
+        struct cfl_array *cfl_arr;
+        struct cfl_kvlist *cfl_kvlist;
+    };
+};
+
+int ctr_decode_opentelemetry_create(struct ctrace **out_ctr, char *in_buf, size_t in_size,
+                                    size_t *offset);
+void ctr_decode_opentelemetry_destroy(struct ctrace *ctr);
+
+#endif
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_msgpack.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_msgpack.h
new file mode 100644
index 000000000..1229a33f6
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_msgpack.h
@@ -0,0 +1,28 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_ENCODE_MSGPACK_H
+#define CTR_ENCODE_MSGPACK_H
+
+#include <ctraces/ctraces.h>
+
+int ctr_encode_msgpack_create(struct ctrace *ctx,  char **out_buf, size_t *out_size);
+void ctr_encode_msgpack_destroy(char *buf);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_opentelemetry.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_opentelemetry.h
new file mode 100644
index 000000000..ed6093658
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_opentelemetry.h
@@ -0,0 +1,28 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CMT_ENCODE_OPENTELEMETRY_H
+#define CMT_ENCODE_OPENTELEMETRY_H
+
+#include <ctraces/ctraces.h>
+
+cfl_sds_t ctr_encode_opentelemetry_create(struct ctrace *ctr);
+void ctr_encode_opentelemetry_destroy(cfl_sds_t text);
+
+#endif
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_text.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_text.h
new file mode 100644
index 000000000..a9fa12d45
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_encode_text.h
@@ -0,0 +1,29 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_ENCODE_TEXT_H
+#define CTR_ENCODE_TEXT_H
+
+#include <ctraces/ctraces.h>
+
+cfl_sds_t ctr_encode_text_create(struct ctrace *ctx);
+void ctr_encode_text_destroy(cfl_sds_t text);
+
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_id.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_id.h
new file mode 100644
index 000000000..91e27e9d3
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_id.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_ID_H
+#define CTR_ID_H
+
+#define CTR_ID_DEFAULT_SIZE     16
+#define CTR_ID_OTEL_TRACE_SIZE  16
+#define CTR_ID_OTEL_SPAN_SIZE    8
+
+#define CTR_ID_TRACE_DEFAULT         "000000F1BI700000000000F1BI700000"
+#define CTR_ID_SPAN_DEFAULT          "000000F1BI700000"
+
+struct ctrace_id {
+    cfl_sds_t buf;
+};
+
+struct ctrace_id *ctr_id_create_random(size_t size);
+struct ctrace_id *ctr_id_create(void *buf, size_t len);
+void ctr_id_destroy(struct ctrace_id *cid);
+int ctr_id_set(struct ctrace_id *cid, void *buf, size_t len);
+int ctr_id_cmp(struct ctrace_id *cid1, struct ctrace_id *cid2);
+size_t ctr_id_get_len(struct ctrace_id *cid);
+void *ctr_id_get_buf(struct ctrace_id *cid);
+cfl_sds_t ctr_id_to_lower_base16(struct ctrace_id *cid);
+struct ctrace_id *ctr_id_from_base16(cfl_sds_t id);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_info.h.in b/fluent-bit/lib/ctraces/include/ctraces/ctr_info.h.in
new file mode 100644
index 000000000..98210fd14
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_info.h.in
@@ -0,0 +1,28 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_INFO_H
+#define CTR_INFO_H
+
+#define CTR_SOURCE_DIR "@CMAKE_SOURCE_DIR@"
+
+/* General flags set by /CMakeLists.txt */
+@CTR_BUILD_FLAGS@
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_link.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_link.h
new file mode 100644
index 000000000..6ff64741e
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_link.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_LINK_H
+#define CTR_LINK_H
+
+#include <ctraces/ctraces.h>
+
+struct ctrace_link {
+	struct ctrace_id *trace_id;       /* the unique traceID    */
+    struct ctrace_id *span_id;        /* the unique span ID    */
+	cfl_sds_t trace_state;            /* trace_state           */
+    struct ctrace_attributes *attr;   /* attributes */
+    uint32_t dropped_attr_count;      /* number of attributes that were discarded */
+
+    /* --- INTERNAL --- */
+    struct cfl_list _head;            /* link to 'struct span->links' list */
+};
+
+struct ctrace_link *ctr_link_create(struct ctrace_span *span,
+                                    void *trace_id_buf, size_t trace_id_len,
+                                    void *span_id_buf, size_t span_id_len);
+
+struct ctrace_link *ctr_link_create_with_cid(struct ctrace_span *span,
+                                             struct ctrace_id *trace_id_cid,
+					 					     struct ctrace_id *span_id_cid);
+
+int ctr_link_set_trace_state(struct ctrace_link *link, char *trace_state);
+int ctr_link_set_attributes(struct ctrace_link *link, struct ctrace_attributes *attr);
+void ctr_link_set_dropped_attr_count(struct ctrace_link *link, uint32_t count);
+
+void ctr_link_destroy(struct ctrace_link *link);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_log.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_log.h
new file mode 100644
index 000000000..c4aae2ad1
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_log.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_LOG_H
+#define CTR_LOG_H
+
+#include <errno.h>
+
+/* Message types */
+#define CTR_LOG_OFF     0
+#define CTR_LOG_ERROR   1
+#define CTR_LOG_WARN    2
+#define CTR_LOG_INFO    3  /* default */
+#define CTR_LOG_DEBUG   4
+#define CTR_LOG_TRACE   5
+
+
+#define CTR_LOG_BUF_SIZE  256
+
+void ctr_log_print(void *ctx, int level, const char *file, int line,
+                     const char *fmt, ...);
+int ctr_errno_print(int errnum, const char *file, int line);
+
+#define ctr_log_error(ctx, fmt, ...)                    \
+    ctr_log_print(ctx, CTR_LOG_ERROR, __FILENAME__,     \
+                  __LINE__, fmt, ##__VA_ARGS__)
+
+#define ctr_log_warn(ctx, fmt, ...)                 \
+    ctr_log_print(ctx, CTR_LOG_WARN, __FILENAME__,  \
+                  __LINE__, fmt, ##__VA_ARGS__)
+
+#define ctr_log_info(ctx, fmt, ...)                 \
+    ctr_log_print(ctx, CTR_LOG_INFO, __FILENAME__,  \
+                  __LINE__, fmt, ##__VA_ARGS__)
+
+#define ctr_log_debug(ctx, fmt, ...)                \
+    ctr_log_print(ctx, CTR_LOG_DEBUG, __FILENAME__, \
+                  __LINE__, fmt, ##__VA_ARGS__)
+
+#define ctr_log_trace(ctx, fmt, ...)                \
+    ctr_log_print(ctx, CTR_LOG_TRACE, __FILENAME__, \
+                  __LINE__, fmt, ##__VA_ARGS__)
+
+#ifdef __FILENAME__
+#define ctr_errno() ctr_errno_print(errno, __FILENAME__, __LINE__)
+#else
+#define ctr_errno() ctr_errno_print(errno, __FILE__, __LINE__)
+#endif
+
+#ifdef _WIN32
+void ctr_winapi_error_print(const char *func, int line);
+#define ctr_winapi_error() ctr_winapi_error_print(__func__, __LINE__)
+#endif
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils.h
new file mode 100644
index 000000000..84f4aaa32
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils.h
@@ -0,0 +1,56 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_MPACK_UTILS_H
+#define CTR_MPACK_UTILS_H
+
+#include <ctraces/ctr_mpack_utils_defs.h>
+#include <cfl/cfl_sds.h>
+#include <mpack/mpack.h>
+
+typedef int (*ctr_mpack_unpacker_entry_callback_fn_t)(mpack_reader_t *reader,
+                                                      size_t index, void *context);
+
+struct ctr_mpack_map_entry_callback_t {
+    const char                            *identifier;
+    ctr_mpack_unpacker_entry_callback_fn_t handler;
+};
+
+int ctr_mpack_consume_nil_tag(mpack_reader_t *reader);
+int ctr_mpack_consume_double_tag(mpack_reader_t *reader, double *output_buffer);
+int ctr_mpack_consume_int_tag(mpack_reader_t *reader, int64_t *output_buffer);
+int ctr_mpack_consume_int32_tag(mpack_reader_t *reader, int32_t *output_buffer);
+int ctr_mpack_consume_int64_tag(mpack_reader_t *reader, int64_t *output_buffer);
+int ctr_mpack_consume_uint_tag(mpack_reader_t *reader, uint64_t *output_buffer);
+int ctr_mpack_consume_uint32_tag(mpack_reader_t *reader, uint32_t *output_buffer);
+int ctr_mpack_consume_uint64_tag(mpack_reader_t *reader, uint64_t *output_buffer);
+int ctr_mpack_consume_string_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer);
+int ctr_mpack_consume_binary_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer);
+int ctr_mpack_consume_string_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer);
+int ctr_mpack_consume_binary_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer);
+int ctr_mpack_unpack_map(mpack_reader_t *reader,
+                         struct ctr_mpack_map_entry_callback_t *callback_list,
+                         void *context);
+int ctr_mpack_unpack_array(mpack_reader_t *reader,
+                           ctr_mpack_unpacker_entry_callback_fn_t entry_processor_callback,
+                           void *context);
+int ctr_mpack_peek_array_length(mpack_reader_t *reader);
+mpack_type_t ctr_mpack_peek_type(mpack_reader_t *reader);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils_defs.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils_defs.h
new file mode 100644
index 000000000..239f0d8e2
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_mpack_utils_defs.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CMetrics
+ *  ========
+ *  Copyright 2021 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_MPACK_UTILS_DEFS_H
+#define CTR_MPACK_UTILS_DEFS_H
+
+#define CTR_MPACK_SUCCESS                    0
+#define CTR_MPACK_INSUFFICIENT_DATA          1
+#define CTR_MPACK_INVALID_ARGUMENT_ERROR     2
+#define CTR_MPACK_ALLOCATION_ERROR           3
+#define CTR_MPACK_CORRUPT_INPUT_DATA_ERROR   4
+#define CTR_MPACK_CONSUME_ERROR              5
+#define CTR_MPACK_ENGINE_ERROR               6
+#define CTR_MPACK_PENDING_MAP_ENTRIES        7
+#define CTR_MPACK_PENDING_ARRAY_ENTRIES      8
+#define CTR_MPACK_UNEXPECTED_KEY_ERROR       9
+#define CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR 10
+#define CTR_MPACK_ERROR_CUTOFF               20
+
+#define CTR_MPACK_MAX_ARRAY_ENTRY_COUNT      65535
+#define CTR_MPACK_MAX_MAP_ENTRY_COUNT        512
+#define CTR_MPACK_MAX_STRING_LENGTH          (1024 * 1000)
+
+#endif
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_random.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_random.h
new file mode 100644
index 000000000..178a2f853
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_random.h
@@ -0,0 +1,27 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_RANDOM_H
+#define CTR_RANDOM_H
+
+#include <ctraces/ctraces.h>
+
+ssize_t ctr_random_get(void *buf, size_t len);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_resource.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_resource.h
new file mode 100644
index 000000000..772931c1b
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_resource.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_RESOURCE_H
+#define CTR_RESOURCE_H
+
+#include <ctraces/ctraces.h>
+
+struct ctrace_resource {
+    uint32_t dropped_attr_count;      /* number of attributes that were discarded */
+    struct ctrace_attributes *attr;   /* attributes */
+};
+
+struct ctrace_resource_span {
+    struct ctrace_resource *resource;
+    struct cfl_list scope_spans;
+    cfl_sds_t schema_url;
+    struct cfl_list _head;               /* link to ctraces->resource_span list */
+};
+
+/* resource */
+struct ctrace_resource *ctr_resource_create();
+struct ctrace_resource *ctr_resource_create_default();
+int ctr_resource_set_attributes(struct ctrace_resource *res, struct ctrace_attributes *attr);
+void ctr_resource_set_dropped_attr_count(struct ctrace_resource *res, uint32_t count);
+void ctr_resource_destroy(struct ctrace_resource *res);
+
+/* resource_span */
+struct ctrace_resource_span *ctr_resource_span_create(struct ctrace *ctx);
+struct ctrace_resource *ctr_resource_span_get_resource(struct ctrace_resource_span *resource_span);
+int ctr_resource_span_set_schema_url(struct ctrace_resource_span *resource_span, char *url);
+void ctr_resource_span_destroy(struct ctrace_resource_span *resource_span);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_scope.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_scope.h
new file mode 100644
index 000000000..98faca943
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_scope.h
@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_SCOPE_SPAN_H
+#define CTR_SCOPE_SPAN_H
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_resource.h>
+
+struct ctrace_instrumentation_scope {
+    cfl_sds_t name;
+    cfl_sds_t version;
+    uint32_t dropped_attr_count;      /* number of attributes that were discarded */
+    struct ctrace_attributes *attr;   /* attributes */
+};
+
+struct ctrace_scope_span {
+    struct ctrace_instrumentation_scope *instrumentation_scope;
+    struct cfl_list spans;
+    cfl_sds_t schema_url;
+    struct cfl_list _head;           /* link to ctrace_resource_span->scope_spans list */
+};
+
+/* scope span */
+struct ctrace_scope_span *ctr_scope_span_create(struct ctrace_resource_span *resource_span);
+void ctr_scope_span_destroy(struct ctrace_scope_span *scope_span);
+int ctr_scope_span_set_schema_url(struct ctrace_scope_span *scope_span, char *url);
+void ctr_scope_span_set_instrumentation_scope(struct ctrace_scope_span *scope_span, struct ctrace_instrumentation_scope *ins_scope);
+
+/* instrumentation scope */
+struct ctrace_instrumentation_scope *ctr_instrumentation_scope_create(char *name, char *version,
+                                                                      uint32_t dropped_attr_count,
+                                                                      struct ctrace_attributes *attr);
+void ctr_instrumentation_scope_destroy(struct ctrace_instrumentation_scope *ins_scope);
+
+#endif
+
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_span.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_span.h
new file mode 100644
index 000000000..7947b6f73
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_span.h
@@ -0,0 +1,157 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_SPAN_H
+#define CTR_SPAN_H
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_scope.h>
+
+/*
+ * OpenTelemetry Trace Protobuf defition
+ * -------------------------------------
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto
+ */
+
+/* Span kind */
+#define CTRACE_SPAN_UNSPECIFIED   0
+#define CTRACE_SPAN_INTERNAL      1
+#define CTRACE_SPAN_SERVER        2
+#define CTRACE_SPAN_CLIENT        3
+#define CTRACE_SPAN_PRODUCER      4
+#define CTRACE_SPAN_CONSUMER      5
+
+/* Status code */
+#define CTRACE_SPAN_STATUS_CODE_UNSET  0
+#define CTRACE_SPAN_STATUS_CODE_OK     1
+#define CTRACE_SPAN_STAUTS_CODE_ERROR  2
+
+struct ctrace_span_status {
+    int code;
+    cfl_sds_t message;
+};
+
+struct ctrace_span_event {
+    uint64_t time_unix_nano;
+
+    cfl_sds_t name;
+
+    /* event attributes */
+    struct ctrace_attributes *attr;
+
+    /* number of attributes that were discarded */
+    uint32_t dropped_attr_count;
+
+    /* ---- INTERNAL --- */
+    struct cfl_list _head;
+};
+
+/* Span */
+struct ctrace_span {
+    struct ctrace_id *trace_id;       /* the unique span ID    */
+    struct ctrace_id *span_id;        /* the unique span ID    */
+    struct ctrace_id *parent_span_id; /* any parent ? a NULL means a root span */
+    cfl_sds_t trace_state;            /* trace state */
+
+    cfl_sds_t name;                   /* user-name assigned */
+
+    int kind;                         /* span kind */
+    uint64_t start_time_unix_nano;    /* start time */
+    uint64_t end_time_unix_nano;      /* end time */
+
+    struct ctrace_attributes *attr;   /* attributes */
+    uint32_t dropped_attr_count;      /* number of attributes that were discarded */
+
+    struct cfl_list events;           /* events     */
+    uint32_t dropped_events_count;    /* number of events that were discarded */
+
+    struct cfl_list links;            /* links */
+    uint32_t dropped_links_count;     /* number of links that were discarded */
+
+    struct ctrace_span_status status; /* status code */
+
+    /* --- INTERNAL --- */
+
+    /* link to 'struct scope_span->spans' list */
+    struct cfl_list _head;
+
+    /* link to global list on 'struct ctrace->span_list' */
+    struct cfl_list _head_global;
+
+
+    /* references from parent contexts */
+    struct ctrace_scope_span *scope_span;
+    struct ctrace *ctx;            /* parent ctrace context */
+};
+
+struct ctrace_span *ctr_span_create(struct ctrace *ctx, struct ctrace_scope_span *scope_span, cfl_sds_t name,
+                                    struct ctrace_span *parent);
+
+void ctr_span_destroy(struct ctrace_span *span);
+
+int ctr_span_set_status(struct ctrace_span *span, int code, char *message);
+void ctr_span_set_dropped_events_count(struct ctrace_span *span, uint32_t count);
+
+/* span IDs */
+int ctr_span_set_trace_id(struct ctrace_span *span, void *buf, size_t len);
+int ctr_span_set_trace_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid);
+int ctr_span_set_span_id(struct ctrace_span *span, void *buf, size_t len);
+int ctr_span_set_span_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid);
+int ctr_span_set_parent_span_id(struct ctrace_span *span, void *buf, size_t len);
+int ctr_span_set_parent_span_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid);
+
+/* attributes */
+int ctr_span_set_attribute_string(struct ctrace_span *span, char *key, char *value);
+int ctr_span_set_attribute_bool(struct ctrace_span *span, char *key, int b);
+int ctr_span_set_attribute_int64(struct ctrace_span *span, char *key, int64_t value);
+int ctr_span_set_attribute_double(struct ctrace_span *span, char *key, double value);
+int ctr_span_set_attribute_array(struct ctrace_span *span, char *key,
+                                 struct cfl_array *value);
+int ctr_span_set_attribute_kvlist(struct ctrace_span *span, char *key,
+                                  struct cfl_kvlist *value);
+void ctr_span_set_dropped_attributes_count(struct ctrace_span *span, uint32_t count);
+
+
+/* time */
+void ctr_span_start(struct ctrace *ctx, struct ctrace_span *span);
+void ctr_span_start_ts(struct ctrace *ctx, struct ctrace_span *span, uint64_t ts);
+
+void ctr_span_end(struct ctrace *ctx, struct ctrace_span *span);
+void ctr_span_end_ts(struct ctrace *ctx, struct ctrace_span *span, uint64_t ts);
+
+/* kind */
+int ctr_span_kind_set(struct ctrace_span *span, int kind);
+char *ctr_span_kind_string(struct ctrace_span *span);
+
+/* events */
+struct ctrace_span_event *ctr_span_event_add(struct ctrace_span *span, char *name);
+struct ctrace_span_event *ctr_span_event_add_ts(struct ctrace_span *span, char *name, uint64_t ts);
+void ctr_span_event_set_dropped_attributes_count(struct ctrace_span_event *event, uint32_t count);
+void ctr_span_event_delete(struct ctrace_span_event *event);
+
+int ctr_span_event_set_attribute_string(struct ctrace_span_event *event, char *key, char *value);
+int ctr_span_event_set_attribute_bool(struct ctrace_span_event *event, char *key, int b);
+int ctr_span_event_set_attribute_int(struct ctrace_span_event *event, char *key, int value);
+int ctr_span_event_set_attribute_double(struct ctrace_span_event *event, char *key, double value);
+int ctr_span_event_set_attribute_array(struct ctrace_span_event *event, char *key,
+                                       struct cfl_array *value);
+int ctr_span_event_set_attribute_kvlist(struct ctrace_span_event *event, char *key,
+                                        struct cfl_kvlist *value);
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_variant_utils.h b/fluent-bit/lib/ctraces/include/ctraces/ctr_variant_utils.h
new file mode 100644
index 000000000..c338be1b0
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_variant_utils.h
@@ -0,0 +1,627 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CMetrics
+ *  ========
+ *  Copyright 2021 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_VARIANT_UTILS_H
+#define CTR_VARIANT_UTILS_H
+
+#include <mpack/mpack.h>
+
+/* These are the only functions meant for general use,
+ * the reason why the kvlist packing and unpacking
+ * functions are exposed is the internal and external
+ * metadata kvlists in the cmetrics context are not
+ * contained by a variant instance.
+ *
+ * Result :
+ * Upon success all of these return 0, otherwise they will
+ * raise the innermost error code which should be treated
+ * as an opaque value.
+ *
+ * Notes :
+ * When decoding -1 means the check after mpack_read_tag
+ * failed and -2 means the type was not the one expected
+ */
+
+static inline int pack_cfl_variant(mpack_writer_t *writer,
+                                   struct cfl_variant *value);
+
+static inline int pack_cfl_variant_kvlist(mpack_writer_t *writer,
+                                          struct cfl_kvlist *kvlist);
+
+static inline int unpack_cfl_variant(mpack_reader_t *reader,
+                                     struct cfl_variant **value);
+
+static inline int unpack_cfl_kvlist(mpack_reader_t *reader,
+                                    struct cfl_kvlist **result_kvlist);
+
+/* Packers */
+static inline int pack_cfl_variant_string(mpack_writer_t *writer,
+                                          char *value)
+{
+    mpack_write_cstr(writer, value);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_binary(mpack_writer_t *writer,
+                                          char *value,
+                                          size_t length)
+{
+    mpack_write_bin(writer, value, length);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_boolean(mpack_writer_t *writer,
+                                           unsigned int value)
+{
+    mpack_write_bool(writer, value);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_int64(mpack_writer_t *writer,
+                                         int64_t value)
+{
+    mpack_write_int(writer, value);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_double(mpack_writer_t *writer,
+                                          double value)
+{
+    mpack_write_double(writer, value);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_array(mpack_writer_t *writer,
+                                         struct cfl_array *array)
+{
+    size_t              entry_count;
+    struct cfl_variant *entry_value;
+    int                 result;
+    size_t              index;
+
+    entry_count = array->entry_count;
+
+    mpack_start_array(writer, entry_count);
+
+    for (index = 0 ; index < entry_count ; index++) {
+        entry_value = cfl_array_fetch_by_index(array, index);
+
+        if (entry_value == NULL) {
+            return -1;
+        }
+
+        result = pack_cfl_variant(writer, entry_value);
+
+        if (result != 0) {
+            return result;
+        }
+    }
+
+    mpack_finish_array(writer);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant_kvlist(mpack_writer_t *writer,
+                                          struct cfl_kvlist *kvlist) {
+    size_t             entry_count;
+    struct cfl_list   *iterator;
+    struct cfl_kvpair *kvpair;
+    int                result;
+
+    entry_count = cfl_kvlist_count(kvlist);
+
+    mpack_start_map(writer, entry_count);
+
+    cfl_list_foreach(iterator, &kvlist->list) {
+        kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head);
+
+        mpack_write_cstr(writer, kvpair->key);
+
+        result = pack_cfl_variant(writer, kvpair->val);
+
+        if (result != 0) {
+            return result;
+        }
+    }
+
+    mpack_finish_map(writer);
+
+    return 0;
+}
+
+static inline int pack_cfl_variant(mpack_writer_t *writer,
+                                   struct cfl_variant *value)
+{
+    int result;
+
+    if (value->type == CFL_VARIANT_STRING) {
+        result = pack_cfl_variant_string(writer, value->data.as_string);
+    }
+    else if (value->type == CFL_VARIANT_BOOL) {
+        result = pack_cfl_variant_boolean(writer, value->data.as_bool);
+    }
+    else if (value->type == CFL_VARIANT_INT) {
+        result = pack_cfl_variant_int64(writer, value->data.as_int64);
+    }
+    else if (value->type == CFL_VARIANT_DOUBLE) {
+        result = pack_cfl_variant_double(writer, value->data.as_double);
+    }
+    else if (value->type == CFL_VARIANT_ARRAY) {
+        result = pack_cfl_variant_array(writer, value->data.as_array);
+    }
+    else if (value->type == CFL_VARIANT_KVLIST) {
+        result = pack_cfl_variant_kvlist(writer, value->data.as_kvlist);
+    }
+    else if (value->type == CFL_VARIANT_BYTES) {
+        result = pack_cfl_variant_binary(writer,
+                                         value->data.as_bytes,
+                                         cfl_sds_len(value->data.as_bytes));
+    }
+    else if (value->type == CFL_VARIANT_REFERENCE) {
+        result = pack_cfl_variant_string(writer, value->data.as_string);
+    }
+    else {
+        result = -1;
+    }
+
+    return result;
+}
+
+/* Unpackers */
+
+static inline int unpack_cfl_variant_read_tag(mpack_reader_t *reader,
+                                              mpack_tag_t *tag,
+                                              mpack_type_t expected_type)
+{
+    *tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return -1;
+    }
+
+    if (mpack_tag_type(tag) != expected_type) {
+        return -2;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_array(mpack_reader_t *reader,
+                                   struct cfl_array **result_array)
+{
+    struct cfl_array   *internal_array;
+    size_t              entry_count;
+    struct cfl_variant *entry_value;
+    int                 result;
+    size_t              index;
+    mpack_tag_t         tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_array);
+
+    if (result != 0) {
+        return result;
+    }
+
+    entry_count = mpack_tag_array_count(&tag);
+
+    internal_array = cfl_array_create(entry_count);
+
+    if (internal_array == NULL) {
+        return -3;
+    }
+
+    for (index = 0 ; index < entry_count ; index++) {
+        result = unpack_cfl_variant(reader, &entry_value);
+
+        if (result != 0) {
+            cfl_array_destroy(internal_array);
+
+            return -4;
+        }
+
+        result = cfl_array_append(internal_array, entry_value);
+
+        if (result != 0) {
+            cfl_array_destroy(internal_array);
+
+            return -5;
+        }
+    }
+
+    mpack_done_array(reader);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        cfl_array_destroy(internal_array);
+
+        return -6;
+    }
+
+    *result_array = internal_array;
+
+    return 0;
+}
+
+static inline int unpack_cfl_kvlist(mpack_reader_t *reader,
+                                    struct cfl_kvlist **result_kvlist)
+{
+    struct cfl_kvlist   *internal_kvlist;
+    char                 key_name[256];
+    size_t               entry_count;
+    size_t               key_length;
+    struct cfl_variant  *key_value;
+    mpack_tag_t          key_tag;
+    int                  result;
+    size_t               index;
+    mpack_tag_t          tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_map);
+
+    if (result != 0) {
+        return result;
+    }
+
+    entry_count = mpack_tag_map_count(&tag);
+
+    internal_kvlist = cfl_kvlist_create();
+
+    if (internal_kvlist == NULL) {
+        return -3;
+    }
+
+    result = 0;
+    key_value = NULL;
+
+    for (index = 0 ; index < entry_count ; index++) {
+        result = unpack_cfl_variant_read_tag(reader, &key_tag, mpack_type_str);
+
+        if (result != 0) {
+            result = -4;
+
+            break;
+        }
+
+        key_length = mpack_tag_str_length(&key_tag);
+
+        if (key_length >= sizeof(key_name)) {
+            result = -5;
+
+            break;
+        }
+
+        mpack_read_cstr(reader, key_name, sizeof(key_name), key_length);
+
+        key_name[key_length] = '\0';
+
+        mpack_done_str(reader);
+
+        if (mpack_ok != mpack_reader_error(reader)) {
+            result = -6;
+
+            break;
+        }
+
+        result = unpack_cfl_variant(reader, &key_value);
+
+        if (result != 0) {
+            printf("VARIANT UNPACK ERROR : [%s] = %d\n", key_name, result);
+            result = -7;
+
+            break;
+        }
+
+        result = cfl_kvlist_insert(internal_kvlist, key_name, key_value);
+
+        if (result != 0) {
+            result = -8;
+
+            break;
+        }
+
+        key_value = NULL;
+    }
+
+    mpack_done_map(reader);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        result = -9;
+    }
+
+    if (result != 0) {
+        cfl_kvlist_destroy(internal_kvlist);
+
+        if (key_value != NULL) {
+            cfl_variant_destroy(key_value);
+        }
+    }
+    else {
+        *result_kvlist = internal_kvlist;
+    }
+
+    return result;
+}
+
+static inline int unpack_cfl_variant_string(mpack_reader_t *reader,
+                                            struct cfl_variant **value)
+{
+    size_t      value_length;
+    char       *value_data;
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_str);
+
+    if (result != 0) {
+        return result;
+    }
+
+    value_length = mpack_tag_str_length(&tag);
+
+    value_data = cfl_sds_create_size(value_length + 1);
+
+    if (value_data == NULL) {
+        return -3;
+    }
+
+    cfl_sds_set_len(value_data, value_length);
+
+    mpack_read_cstr(reader, value_data, value_length + 1, value_length);
+
+    mpack_done_str(reader);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        cfl_sds_destroy(value_data);
+
+        return -4;
+    }
+
+    *value = cfl_variant_create_from_reference(value_data);
+
+    if (*value == NULL) {
+        return -5;
+    }
+
+    (*value)->type = CFL_VARIANT_STRING;
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_binary(mpack_reader_t *reader,
+                                            struct cfl_variant **value)
+{
+    size_t      value_length;
+    char       *value_data;
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_bin);
+
+    if (result != 0) {
+        return result;
+    }
+
+    value_length = mpack_tag_bin_length(&tag);
+
+    value_data = cfl_sds_create_size(value_length);
+
+    if (value_data == NULL) {
+        return -3;
+    }
+
+    cfl_sds_set_len(value_data, value_length);
+
+    mpack_read_bytes(reader, value_data, value_length);
+
+    mpack_done_bin(reader);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        cfl_sds_destroy(value_data);
+
+        return -4;
+    }
+
+    *value = cfl_variant_create_from_reference(value_data);
+
+    if (*value == NULL) {
+        return -5;
+    }
+
+    (*value)->type = CFL_VARIANT_BYTES;
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_boolean(mpack_reader_t *reader,
+                                             struct cfl_variant **value)
+{
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_bool);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_bool((unsigned int) mpack_tag_bool_value(&tag));
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_uint64(mpack_reader_t *reader,
+                                            struct cfl_variant **value)
+{
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_uint);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_int64((int64_t) mpack_tag_uint_value(&tag));
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_int64(mpack_reader_t *reader,
+                                           struct cfl_variant **value)
+{
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_int);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_int64((int64_t) mpack_tag_int_value(&tag));
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_double(mpack_reader_t *reader,
+                                            struct cfl_variant **value)
+{
+    int         result;
+    mpack_tag_t tag;
+
+    result = unpack_cfl_variant_read_tag(reader, &tag, mpack_type_double);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_double(mpack_tag_double_value(&tag));
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_array(mpack_reader_t *reader,
+                                           struct cfl_variant **value)
+{
+    struct cfl_array *unpacked_array;
+    int               result;
+
+    result = unpack_cfl_array(reader, &unpacked_array);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_array(unpacked_array);
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant_kvlist(mpack_reader_t *reader,
+                                            struct cfl_variant **value)
+{
+    struct cfl_kvlist *unpacked_kvlist;
+    int                result;
+
+    result = unpack_cfl_kvlist(reader, &unpacked_kvlist);
+
+    if (result != 0) {
+        return result;
+    }
+
+    *value = cfl_variant_create_from_kvlist(unpacked_kvlist);
+
+    if (*value == NULL) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static inline int unpack_cfl_variant(mpack_reader_t *reader,
+                                     struct cfl_variant **value)
+{
+    mpack_type_t value_type;
+    int          result;
+    mpack_tag_t  tag;
+
+    tag = mpack_peek_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return -1;
+    }
+
+    value_type = mpack_tag_type(&tag);
+
+    if (value_type == mpack_type_str) {
+        result = unpack_cfl_variant_string(reader, value);
+    }
+    else if (value_type == mpack_type_bool) {
+        result = unpack_cfl_variant_boolean(reader, value);
+    }
+    else if (value_type == mpack_type_int) {
+        result = unpack_cfl_variant_int64(reader, value);
+    }
+    else if (value_type == mpack_type_uint) {
+        result = unpack_cfl_variant_uint64(reader, value);
+    }
+    else if (value_type == mpack_type_double) {
+        result = unpack_cfl_variant_double(reader, value);
+    }
+    else if (value_type == mpack_type_array) {
+        result = unpack_cfl_variant_array(reader, value);
+    }
+    else if (value_type == mpack_type_map) {
+        result = unpack_cfl_variant_kvlist(reader, value);
+    }
+    else if (value_type == mpack_type_bin) {
+        result = unpack_cfl_variant_binary(reader, value);
+    }
+    else {
+        result = -1;
+    }
+
+    return result;
+}
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctr_version.h.in b/fluent-bit/lib/ctraces/include/ctraces/ctr_version.h.in
new file mode 100644
index 000000000..4d04118d7
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctr_version.h.in
@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_VERSION_H
+#define CTR_VERSION_H
+
+/* Helpers to convert/format version string */
+#define STR_HELPER(s)      #s
+#define STR(s)             STR_HELPER(s)
+
+/* CTraces Version */
+#define CTR_VERSION_MAJOR   @CTR_VERSION_MAJOR@
+#define CTR_VERSION_MINOR   @CTR_VERSION_MINOR@
+#define CTR_VERSION_PATCH   @CTR_VERSION_PATCH@
+#define CTR_VERSION         (CTR_VERSION_MAJOR * 10000 \
+                             CTR_VERSION_MINOR * 100   \
+                             CTR_VERSION_PATCH)
+#define CTR_VERSION_STR     "@CTR_VERSION_STR@"
+
+char *ctr_version();
+
+#endif
diff --git a/fluent-bit/lib/ctraces/include/ctraces/ctraces.h b/fluent-bit/lib/ctraces/include/ctraces/ctraces.h
new file mode 100644
index 000000000..0ca02c6f8
--- /dev/null
+++ b/fluent-bit/lib/ctraces/include/ctraces/ctraces.h
@@ -0,0 +1,101 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_H
+#define CTR_H
+
+#define CTR_FALSE   0
+#define CTR_TRUE    !CTR_FALSE
+
+#include <ctraces/ctr_info.h>
+#include <ctraces/ctr_compat.h>
+
+/* local libs */
+#include <cfl/cfl.h>
+#include <mpack/mpack.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* ctrace options creation keys */
+#define CTR_OPTS_TRACE_ID   0
+
+/* options is unused for now */
+struct ctrace_opts {
+    /* windows compiler: error C2016: C requires that a struct or union have at least one member */
+    int _make_windows_happy;
+};
+
+struct ctrace {
+    /*
+     * last_span_id represents the higher span id number assigned, every time
+     * a new span is created this value gets incremented.
+     */
+    uint64_t last_span_id;
+
+    /*
+     * When the user creates a new resource, we add it to a linked list so on
+     * every span we just keep a reference.
+     */
+    struct cfl_list resource_spans;
+
+    /*
+     * This 'span_list' is used for internal purposes only when a caller needs to
+     * iterate all spans linearly without getting inside a loop with resource_span, scope_spans, etc.
+     *
+     * note: every 'span' is linked to a 'scope_span' and to 'span_list' (this structure)
+     */
+    struct cfl_list span_list;
+
+    /* logging */
+    int log_level;
+    void (*log_cb)(void *, int, const char *, int, const char *);
+};
+
+struct ctrace *ctr_create(struct ctrace_opts *opts);
+void ctr_destroy(struct ctrace *ctx);
+
+/* options */
+void ctr_opts_init(struct ctrace_opts *opts);
+void ctr_opts_set(struct ctrace_opts *opts, int value, char *val);
+void ctr_opts_exit(struct ctrace_opts *opts);
+
+/* headers that are needed in general */
+#include <ctraces/ctr_info.h>
+#include <ctraces/ctr_id.h>
+#include <ctraces/ctr_random.h>
+#include <ctraces/ctr_version.h>
+#include <ctraces/ctr_span.h>
+#include <ctraces/ctr_scope.h>
+#include <ctraces/ctr_link.h>
+#include <ctraces/ctr_attributes.h>
+#include <ctraces/ctr_log.h>
+#include <ctraces/ctr_resource.h>
+
+/* encoders */
+#include <ctraces/ctr_encode_text.h>
+#include <ctraces/ctr_encode_msgpack.h>
+#include <ctraces/ctr_encode_opentelemetry.h>
+
+/* decoders */
+#include <ctraces/ctr_decode_opentelemetry.h>
+
+
+
+#endif
diff --git a/fluent-bit/lib/ctraces/lib/mpack/CMakeLists.txt b/fluent-bit/lib/ctraces/lib/mpack/CMakeLists.txt
new file mode 100644
index 000000000..bc6e73157
--- /dev/null
+++ b/fluent-bit/lib/ctraces/lib/mpack/CMakeLists.txt
@@ -0,0 +1,31 @@
+set(src
+  src/mpack/mpack.c
+  )
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
+add_definitions(-DMPACK_EXTENSIONS=1)
+add_library(mpack-static STATIC ${src})
+
+# Install Library
+if(MSVC)
+  # Rename the output for Windows environment to avoid naming issues
+  set_target_properties(mpack-static PROPERTIES OUTPUT_NAME libmpack)
+else()
+  set_target_properties(mpack-static PROPERTIES OUTPUT_NAME mpack)
+endif(MSVC)
+
+# Installation Directories
+# ========================
+if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(MPACK_INSTALL_LIBDIR "lib")
+  set(MPACK_INSTALL_INCLUDEDIR "include")
+else()
+  set(MPACK_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  set(MPACK_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include")
+endif()
+
+install(TARGETS mpack-static
+  RUNTIME DESTINATION ${MPACK_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${MPACK_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${MPACK_INSTALL_LIBDIR}
+  COMPONENT library)
diff --git a/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.c b/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.c
new file mode 100644
index 000000000..337ab0955
--- /dev/null
+++ b/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.c
@@ -0,0 +1,6472 @@
+/**
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2015-2018 Nicholas Fraser
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+
+/*
+ * This is the MPack 1.0 amalgamation package.
+ *
+ * http://github.com/ludocode/mpack
+ */
+
+#define MPACK_INTERNAL 1
+#define MPACK_EMIT_INLINE_DEFS 1
+
+#include "mpack.h"
+
+
+/* mpack/mpack-platform.c.c */
+
+
+// We define MPACK_EMIT_INLINE_DEFS and include mpack.h to emit
+// standalone definitions of all (non-static) inline functions in MPack.
+
+#define MPACK_INTERNAL 1
+#define MPACK_EMIT_INLINE_DEFS 1
+
+/* #include "mpack-platform.h" */
+/* #include "mpack.h" */
+
+
+#if MPACK_DEBUG && MPACK_STDIO
+#include <stdarg.h>
+#endif
+
+
+
+#if MPACK_DEBUG
+
+#if MPACK_STDIO
+void mpack_assert_fail_format(const char* format, ...) {
+    char buffer[512];
+    va_list args;
+    va_start(args, format);
+    vsnprintf(buffer, sizeof(buffer), format, args);
+    va_end(args);
+    buffer[sizeof(buffer) - 1] = 0;
+    mpack_assert_fail_wrapper(buffer);
+}
+
+void mpack_break_hit_format(const char* format, ...) {
+    char buffer[512];
+    va_list args;
+    va_start(args, format);
+    vsnprintf(buffer, sizeof(buffer), format, args);
+    va_end(args);
+    buffer[sizeof(buffer) - 1] = 0;
+    mpack_break_hit(buffer);
+}
+#endif
+
+#if !MPACK_CUSTOM_ASSERT
+void mpack_assert_fail(const char* message) {
+    MPACK_UNUSED(message);
+
+    #if MPACK_STDIO
+    fprintf(stderr, "%s\n", message);
+    #endif
+}
+#endif
+
+// We split the assert failure from the wrapper so that a
+// custom assert function can return.
+void mpack_assert_fail_wrapper(const char* message) {
+
+    #ifdef MPACK_GCOV
+    // gcov marks even __builtin_unreachable() as an uncovered line. this
+    // silences it.
+    (mpack_assert_fail(message), __builtin_unreachable());
+
+    #else
+    mpack_assert_fail(message);
+
+    // mpack_assert_fail() is not supposed to return. in case it does, we
+    // abort.
+
+    #if !MPACK_NO_BUILTINS
+    #if defined(__GNUC__) || defined(__clang__)
+    __builtin_trap();
+    #elif defined(WIN32)
+    __debugbreak();
+    #endif
+    #endif
+
+    #if (defined(__GNUC__) || defined(__clang__)) && !MPACK_NO_BUILTINS
+    __builtin_abort();
+    #elif MPACK_STDLIB
+    abort();
+    #endif
+
+    MPACK_UNREACHABLE;
+    #endif
+}
+
+#if !MPACK_CUSTOM_BREAK
+
+// If we have a custom assert handler, break wraps it by default.
+// This allows users of MPack to only implement mpack_assert_fail() without
+// having to worry about the difference between assert and break.
+//
+// MPACK_CUSTOM_BREAK is available to define a separate break handler
+// (which is needed by the unit test suite), but this is not offered in
+// mpack-config.h for simplicity.
+
+#if MPACK_CUSTOM_ASSERT
+void mpack_break_hit(const char* message) {
+    mpack_assert_fail_wrapper(message);
+}
+#else
+void mpack_break_hit(const char* message) {
+    MPACK_UNUSED(message);
+
+    #if MPACK_STDIO
+    fprintf(stderr, "%s\n", message);
+    #endif
+
+    #if defined(__GNUC__) || defined(__clang__) && !MPACK_NO_BUILTINS
+    __builtin_trap();
+    #elif defined(WIN32) && !MPACK_NO_BUILTINS
+    __debugbreak();
+    #elif MPACK_STDLIB
+    abort();
+    #endif
+}
+#endif
+
+#endif
+
+#endif
+
+
+
+// The below are adapted from the C wikibook:
+//     https://en.wikibooks.org/wiki/C_Programming/Strings
+
+#ifndef mpack_memcmp
+int mpack_memcmp(const void* s1, const void* s2, size_t n) {
+     const unsigned char *us1 = (const unsigned char *) s1;
+     const unsigned char *us2 = (const unsigned char *) s2;
+     while (n-- != 0) {
+         if (*us1 != *us2)
+             return (*us1 < *us2) ? -1 : +1;
+         us1++;
+         us2++;
+     }
+     return 0;
+}
+#endif
+
+#ifndef mpack_memcpy
+void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n) {
+    char* MPACK_RESTRICT dst = (char *)s1;
+    const char* MPACK_RESTRICT src = (const char *)s2;
+    while (n-- != 0)
+        *dst++ = *src++;
+    return s1;
+}
+#endif
+
+#ifndef mpack_memmove
+void* mpack_memmove(void* s1, const void* s2, size_t n) {
+    char *p1 = (char *)s1;
+    const char *p2 = (const char *)s2;
+    if (p2 < p1 && p1 < p2 + n) {
+        p2 += n;
+        p1 += n;
+        while (n-- != 0)
+            *--p1 = *--p2;
+    } else
+        while (n-- != 0)
+            *p1++ = *p2++;
+    return s1;
+}
+#endif
+
+#ifndef mpack_memset
+void* mpack_memset(void* s, int c, size_t n) {
+    unsigned char *us = (unsigned char *)s;
+    unsigned char uc = (unsigned char)c;
+    while (n-- != 0)
+        *us++ = uc;
+    return s;
+}
+#endif
+
+#ifndef mpack_strlen
+size_t mpack_strlen(const char* s) {
+    const char* p = s;
+    while (*p != '\0')
+        p++;
+    return (size_t)(p - s);
+}
+#endif
+
+
+
+#if defined(MPACK_MALLOC) && !defined(MPACK_REALLOC)
+void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) {
+    if (new_size == 0) {
+        if (old_ptr)
+            MPACK_FREE(old_ptr);
+        return NULL;
+    }
+
+    void* new_ptr = MPACK_MALLOC(new_size);
+    if (new_ptr == NULL)
+        return NULL;
+
+    mpack_memcpy(new_ptr, old_ptr, used_size);
+    MPACK_FREE(old_ptr);
+    return new_ptr;
+}
+#endif
+
+/* mpack/mpack-common.c.c */
+
+#define MPACK_INTERNAL 1
+
+/* #include "mpack-common.h" */
+
+#if MPACK_DEBUG && MPACK_STDIO
+#include <stdarg.h>
+#endif
+
+const char* mpack_error_to_string(mpack_error_t error) {
+    #if MPACK_STRINGS
+    switch (error) {
+        #define MPACK_ERROR_STRING_CASE(e) case e: return #e
+        MPACK_ERROR_STRING_CASE(mpack_ok);
+        MPACK_ERROR_STRING_CASE(mpack_error_io);
+        MPACK_ERROR_STRING_CASE(mpack_error_invalid);
+        MPACK_ERROR_STRING_CASE(mpack_error_unsupported);
+        MPACK_ERROR_STRING_CASE(mpack_error_type);
+        MPACK_ERROR_STRING_CASE(mpack_error_too_big);
+        MPACK_ERROR_STRING_CASE(mpack_error_memory);
+        MPACK_ERROR_STRING_CASE(mpack_error_bug);
+        MPACK_ERROR_STRING_CASE(mpack_error_data);
+        MPACK_ERROR_STRING_CASE(mpack_error_eof);
+        #undef MPACK_ERROR_STRING_CASE
+    }
+    mpack_assert(0, "unrecognized error %i", (int)error);
+    return "(unknown mpack_error_t)";
+    #else
+    MPACK_UNUSED(error);
+    return "";
+    #endif
+}
+
+const char* mpack_type_to_string(mpack_type_t type) {
+    #if MPACK_STRINGS
+    switch (type) {
+        #define MPACK_TYPE_STRING_CASE(e) case e: return #e
+        MPACK_TYPE_STRING_CASE(mpack_type_missing);
+        MPACK_TYPE_STRING_CASE(mpack_type_nil);
+        MPACK_TYPE_STRING_CASE(mpack_type_bool);
+        MPACK_TYPE_STRING_CASE(mpack_type_float);
+        MPACK_TYPE_STRING_CASE(mpack_type_double);
+        MPACK_TYPE_STRING_CASE(mpack_type_int);
+        MPACK_TYPE_STRING_CASE(mpack_type_uint);
+        MPACK_TYPE_STRING_CASE(mpack_type_str);
+        MPACK_TYPE_STRING_CASE(mpack_type_bin);
+        MPACK_TYPE_STRING_CASE(mpack_type_array);
+        MPACK_TYPE_STRING_CASE(mpack_type_map);
+        #if MPACK_EXTENSIONS
+        MPACK_TYPE_STRING_CASE(mpack_type_ext);
+        #endif
+        #undef MPACK_TYPE_STRING_CASE
+    }
+    mpack_assert(0, "unrecognized type %i", (int)type);
+    return "(unknown mpack_type_t)";
+    #else
+    MPACK_UNUSED(type);
+    return "";
+    #endif
+}
+
+int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right) {
+
+    // positive numbers may be stored as int; convert to uint
+    if (left.type == mpack_type_int && left.v.i >= 0) {
+        left.type = mpack_type_uint;
+        left.v.u = (uint64_t)left.v.i;
+    }
+    if (right.type == mpack_type_int && right.v.i >= 0) {
+        right.type = mpack_type_uint;
+        right.v.u = (uint64_t)right.v.i;
+    }
+
+    if (left.type != right.type)
+        return ((int)left.type < (int)right.type) ? -1 : 1;
+
+    switch (left.type) {
+        case mpack_type_missing: // fallthrough
+        case mpack_type_nil:
+            return 0;
+
+        case mpack_type_bool:
+            return (int)left.v.b - (int)right.v.b;
+
+        case mpack_type_int:
+            if (left.v.i == right.v.i)
+                return 0;
+            return (left.v.i < right.v.i) ? -1 : 1;
+
+        case mpack_type_uint:
+            if (left.v.u == right.v.u)
+                return 0;
+            return (left.v.u < right.v.u) ? -1 : 1;
+
+        case mpack_type_array:
+        case mpack_type_map:
+            if (left.v.n == right.v.n)
+                return 0;
+            return (left.v.n < right.v.n) ? -1 : 1;
+
+        case mpack_type_str:
+        case mpack_type_bin:
+            if (left.v.l == right.v.l)
+                return 0;
+            return (left.v.l < right.v.l) ? -1 : 1;
+
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            if (left.exttype == right.exttype) {
+                if (left.v.l == right.v.l)
+                    return 0;
+                return (left.v.l < right.v.l) ? -1 : 1;
+            }
+            return (int)left.exttype - (int)right.exttype;
+        #endif
+
+        // floats should not normally be compared for equality. we compare
+        // with memcmp() to silence compiler warnings, but this will return
+        // equal if both are NaNs with the same representation (though we may
+        // want this, for instance if you are for some bizarre reason using
+        // floats as map keys.) i'm not sure what the right thing to
+        // do is here. check for NaN first? always return false if the type
+        // is float? use operator== and pragmas to silence compiler warning?
+        // please send me your suggestions.
+        // note also that we don't convert floats to doubles, so when this is
+        // used for ordering purposes, all floats are ordered before all
+        // doubles.
+        case mpack_type_float:
+            return mpack_memcmp(&left.v.f, &right.v.f, sizeof(left.v.f));
+        case mpack_type_double:
+            return mpack_memcmp(&left.v.d, &right.v.d, sizeof(left.v.d));
+    }
+
+    mpack_assert(0, "unrecognized type %i", (int)left.type);
+    return false;
+}
+
+#if MPACK_DEBUG && MPACK_STDIO
+static char mpack_hex_char(uint8_t hex_value) {
+    // Older compilers (e.g. GCC 4.4.7) promote the result of this ternary to
+    // int and warn under -Wconversion, so we have to cast it back to char.
+    return (char)((hex_value < 10) ? (char)('0' + hex_value) : (char)('a' + (hex_value - 10)));
+}
+
+static void mpack_tag_debug_complete_bin_ext(mpack_tag_t tag, size_t string_length, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size)
+{
+    // If at any point in this function we run out of space in the buffer, we
+    // bail out. The outer tag print wrapper will make sure we have a
+    // null-terminator.
+
+    if (string_length == 0 || string_length >= buffer_size)
+        return;
+    buffer += string_length;
+    buffer_size -= string_length;
+
+    size_t total = mpack_tag_bytes(&tag);
+    if (total == 0) {
+        strncpy(buffer, ">", buffer_size);
+        return;
+    }
+
+    strncpy(buffer, ": ", buffer_size);
+    if (buffer_size < 2)
+        return;
+    buffer += 2;
+    buffer_size -= 2;
+
+    size_t hex_bytes = 0;
+    for (size_t i = 0; i < MPACK_PRINT_BYTE_COUNT && i < prefix_size && buffer_size > 2; ++i) {
+        uint8_t byte = (uint8_t)prefix[i];
+        buffer[0] = mpack_hex_char((uint8_t)(byte >> 4));
+        buffer[1] = mpack_hex_char((uint8_t)(byte & 0xfu));
+        buffer += 2;
+        buffer_size -= 2;
+        ++hex_bytes;
+    }
+
+    if (buffer_size != 0)
+        mpack_snprintf(buffer, buffer_size, "%s>", (total > hex_bytes) ? "..." : "");
+}
+
+static void mpack_tag_debug_pseudo_json_bin(mpack_tag_t tag, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size)
+{
+    mpack_assert(mpack_tag_type(&tag) == mpack_type_bin);
+    size_t length = (size_t)mpack_snprintf(buffer, buffer_size, "<binary data of length %u", tag.v.l);
+    mpack_tag_debug_complete_bin_ext(tag, length, buffer, buffer_size, prefix, prefix_size);
+}
+
+#if MPACK_EXTENSIONS
+static void mpack_tag_debug_pseudo_json_ext(mpack_tag_t tag, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size)
+{
+    mpack_assert(mpack_tag_type(&tag) == mpack_type_ext);
+    size_t length = (size_t)mpack_snprintf(buffer, buffer_size, "<ext data of type %i and length %u",
+            mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag));
+    mpack_tag_debug_complete_bin_ext(tag, length, buffer, buffer_size, prefix, prefix_size);
+}
+#endif
+
+static void mpack_tag_debug_pseudo_json_impl(mpack_tag_t tag, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size)
+{
+    switch (tag.type) {
+        case mpack_type_missing:
+            mpack_snprintf(buffer, buffer_size, "<missing!>");
+            return;
+        case mpack_type_nil:
+            mpack_snprintf(buffer, buffer_size, "null");
+            return;
+        case mpack_type_bool:
+            mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false");
+            return;
+        case mpack_type_int:
+            mpack_snprintf(buffer, buffer_size, "%" PRIi64, tag.v.i);
+            return;
+        case mpack_type_uint:
+            mpack_snprintf(buffer, buffer_size, "%" PRIu64, tag.v.u);
+            return;
+        case mpack_type_float:
+            mpack_snprintf(buffer, buffer_size, "%f", tag.v.f);
+            return;
+        case mpack_type_double:
+            mpack_snprintf(buffer, buffer_size, "%f", tag.v.d);
+            return;
+
+        case mpack_type_str:
+            mpack_snprintf(buffer, buffer_size, "<string of %u bytes>", tag.v.l);
+            return;
+        case mpack_type_bin:
+            mpack_tag_debug_pseudo_json_bin(tag, buffer, buffer_size, prefix, prefix_size);
+            return;
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            mpack_tag_debug_pseudo_json_ext(tag, buffer, buffer_size, prefix, prefix_size);
+            return;
+        #endif
+
+        case mpack_type_array:
+            mpack_snprintf(buffer, buffer_size, "<array of %u elements>", tag.v.n);
+            return;
+        case mpack_type_map:
+            mpack_snprintf(buffer, buffer_size, "<map of %u key-value pairs>", tag.v.n);
+            return;
+    }
+
+    mpack_snprintf(buffer, buffer_size, "<unknown!>");
+}
+
+void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size)
+{
+    mpack_assert(buffer_size > 0, "buffer size cannot be zero!");
+    buffer[0] = 0;
+
+    mpack_tag_debug_pseudo_json_impl(tag, buffer, buffer_size, prefix, prefix_size);
+
+    // We always null-terminate the buffer manually just in case the snprintf()
+    // function doesn't null-terminate when the string doesn't fit.
+    buffer[buffer_size - 1] = 0;
+}
+
+static void mpack_tag_debug_describe_impl(mpack_tag_t tag, char* buffer, size_t buffer_size) {
+    switch (tag.type) {
+        case mpack_type_missing:
+            mpack_snprintf(buffer, buffer_size, "missing");
+            return;
+        case mpack_type_nil:
+            mpack_snprintf(buffer, buffer_size, "nil");
+            return;
+        case mpack_type_bool:
+            mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false");
+            return;
+        case mpack_type_int:
+            mpack_snprintf(buffer, buffer_size, "int %" PRIi64, tag.v.i);
+            return;
+        case mpack_type_uint:
+            mpack_snprintf(buffer, buffer_size, "uint %" PRIu64, tag.v.u);
+            return;
+        case mpack_type_float:
+            mpack_snprintf(buffer, buffer_size, "float %f", tag.v.f);
+            return;
+        case mpack_type_double:
+            mpack_snprintf(buffer, buffer_size, "double %f", tag.v.d);
+            return;
+        case mpack_type_str:
+            mpack_snprintf(buffer, buffer_size, "str of %u bytes", tag.v.l);
+            return;
+        case mpack_type_bin:
+            mpack_snprintf(buffer, buffer_size, "bin of %u bytes", tag.v.l);
+            return;
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            mpack_snprintf(buffer, buffer_size, "ext of type %i, %u bytes",
+                    mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag));
+            return;
+        #endif
+        case mpack_type_array:
+            mpack_snprintf(buffer, buffer_size, "array of %u elements", tag.v.n);
+            return;
+        case mpack_type_map:
+            mpack_snprintf(buffer, buffer_size, "map of %u key-value pairs", tag.v.n);
+            return;
+    }
+
+    mpack_snprintf(buffer, buffer_size, "unknown!");
+}
+
+void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size) {
+    mpack_assert(buffer_size > 0, "buffer size cannot be zero!");
+    buffer[0] = 0;
+
+    mpack_tag_debug_describe_impl(tag, buffer, buffer_size);
+
+    // We always null-terminate the buffer manually just in case the snprintf()
+    // function doesn't null-terminate when the string doesn't fit.
+    buffer[buffer_size - 1] = 0;
+}
+#endif
+
+
+
+#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING
+
+#ifndef MPACK_TRACKING_INITIAL_CAPACITY
+// seems like a reasonable number. we grow by doubling, and it only
+// needs to be as long as the maximum depth of the message.
+#define MPACK_TRACKING_INITIAL_CAPACITY 8
+#endif
+
+mpack_error_t mpack_track_init(mpack_track_t* track) {
+    track->count = 0;
+    track->capacity = MPACK_TRACKING_INITIAL_CAPACITY;
+    track->elements = (mpack_track_element_t*)MPACK_MALLOC(sizeof(mpack_track_element_t) * track->capacity);
+    if (track->elements == NULL)
+        return mpack_error_memory;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_grow(mpack_track_t* track) {
+    mpack_assert(track->elements, "null track elements!");
+    mpack_assert(track->count == track->capacity, "incorrect growing?");
+
+    size_t new_capacity = track->capacity * 2;
+
+    mpack_track_element_t* new_elements = (mpack_track_element_t*)mpack_realloc(track->elements,
+            sizeof(mpack_track_element_t) * track->count, sizeof(mpack_track_element_t) * new_capacity);
+    if (new_elements == NULL)
+        return mpack_error_memory;
+
+    track->elements = new_elements;
+    track->capacity = new_capacity;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint32_t count) {
+    mpack_assert(track->elements, "null track elements!");
+    mpack_log("track pushing %s count %i\n", mpack_type_to_string(type), (int)count);
+
+    // grow if needed
+    if (track->count == track->capacity) {
+        mpack_error_t error = mpack_track_grow(track);
+        if (error != mpack_ok)
+            return error;
+    }
+
+    // insert new track
+    track->elements[track->count].type = type;
+    track->elements[track->count].left = count;
+    track->elements[track->count].key_needs_value = false;
+    ++track->count;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type) {
+    mpack_assert(track->elements, "null track elements!");
+    mpack_log("track popping %s\n", mpack_type_to_string(type));
+
+    if (track->count == 0) {
+        mpack_break("attempting to close a %s but nothing was opened!", mpack_type_to_string(type));
+        return mpack_error_bug;
+    }
+
+    mpack_track_element_t* element = &track->elements[track->count - 1];
+
+    if (element->type != type) {
+        mpack_break("attempting to close a %s but the open element is a %s!",
+                mpack_type_to_string(type), mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    if (element->key_needs_value) {
+        mpack_assert(type == mpack_type_map, "key_needs_value can only be true for maps!");
+        mpack_break("attempting to close a %s but an odd number of elements were written",
+                mpack_type_to_string(type));
+        return mpack_error_bug;
+    }
+
+    if (element->left != 0) {
+        mpack_break("attempting to close a %s but there are %i %s left",
+                mpack_type_to_string(type), element->left,
+                (type == mpack_type_map || type == mpack_type_array) ? "elements" : "bytes");
+        return mpack_error_bug;
+    }
+
+    --track->count;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read) {
+    MPACK_UNUSED(read);
+    mpack_assert(track->elements, "null track elements!");
+
+    // if there are no open elements, that's fine, we can read/write elements at will
+    if (track->count == 0)
+        return mpack_ok;
+
+    mpack_track_element_t* element = &track->elements[track->count - 1];
+
+    if (element->type != mpack_type_map && element->type != mpack_type_array) {
+        mpack_break("elements cannot be %s within an %s", read ? "read" : "written",
+                mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    if (element->left == 0 && !element->key_needs_value) {
+        mpack_break("too many elements %s for %s", read ? "read" : "written",
+                mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_element(mpack_track_t* track, bool read) {
+    mpack_error_t error = mpack_track_peek_element(track, read);
+    if (track->count == 0 || error != mpack_ok)
+        return error;
+
+    mpack_track_element_t* element = &track->elements[track->count - 1];
+
+    if (element->type == mpack_type_map) {
+        if (!element->key_needs_value) {
+            element->key_needs_value = true;
+            return mpack_ok; // don't decrement
+        }
+        element->key_needs_value = false;
+    }
+
+    --element->left;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, size_t count) {
+    MPACK_UNUSED(read);
+    mpack_assert(track->elements, "null track elements!");
+
+    if (count > UINT32_MAX) {
+        mpack_break("%s more bytes than could possibly fit in a str/bin/ext!",
+                read ? "reading" : "writing");
+        return mpack_error_bug;
+    }
+
+    if (track->count == 0) {
+        mpack_break("bytes cannot be %s with no open bin, str or ext", read ? "read" : "written");
+        return mpack_error_bug;
+    }
+
+    mpack_track_element_t* element = &track->elements[track->count - 1];
+
+    if (element->type == mpack_type_map || element->type == mpack_type_array) {
+        mpack_break("bytes cannot be %s within an %s", read ? "read" : "written",
+                mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    if (element->left < count) {
+        mpack_break("too many bytes %s for %s", read ? "read" : "written",
+                mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    element->left -= (uint32_t)count;
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, size_t count) {
+    mpack_error_t error = mpack_track_bytes(track, read, count);
+    if (error != mpack_ok)
+        return error;
+
+    mpack_track_element_t* element = &track->elements[track->count - 1];
+
+    if (element->type != mpack_type_str) {
+        mpack_break("the open type must be a string, not a %s", mpack_type_to_string(element->type));
+        return mpack_error_bug;
+    }
+
+    if (element->left != 0) {
+        mpack_break("not all bytes were read; the wrong byte count was requested for a string read.");
+        return mpack_error_bug;
+    }
+
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_check_empty(mpack_track_t* track) {
+    if (track->count != 0) {
+        mpack_break("unclosed %s", mpack_type_to_string(track->elements[0].type));
+        return mpack_error_bug;
+    }
+    return mpack_ok;
+}
+
+mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel) {
+    mpack_error_t error = cancel ? mpack_ok : mpack_track_check_empty(track);
+    if (track->elements) {
+        MPACK_FREE(track->elements);
+        track->elements = NULL;
+    }
+    return error;
+}
+#endif
+
+
+
+static bool mpack_utf8_check_impl(const uint8_t* str, size_t count, bool allow_null) {
+    while (count > 0) {
+        uint8_t lead = str[0];
+
+        // NUL
+        if (!allow_null && lead == '\0') // we don't allow NUL bytes in MPack C-strings
+            return false;
+
+        // ASCII
+        if (lead <= 0x7F) {
+            ++str;
+            --count;
+
+        // 2-byte sequence
+        } else if ((lead & 0xE0) == 0xC0) {
+            if (count < 2) // truncated sequence
+                return false;
+
+            uint8_t cont = str[1];
+            if ((cont & 0xC0) != 0x80) // not a continuation byte
+                return false;
+
+            str += 2;
+            count -= 2;
+
+            uint32_t z = ((uint32_t)(lead & ~0xE0) << 6) |
+                          (uint32_t)(cont & ~0xC0);
+
+            if (z < 0x80) // overlong sequence
+                return false;
+
+        // 3-byte sequence
+        } else if ((lead & 0xF0) == 0xE0) {
+            if (count < 3) // truncated sequence
+                return false;
+
+            uint8_t cont1 = str[1];
+            if ((cont1 & 0xC0) != 0x80) // not a continuation byte
+                return false;
+            uint8_t cont2 = str[2];
+            if ((cont2 & 0xC0) != 0x80) // not a continuation byte
+                return false;
+
+            str += 3;
+            count -= 3;
+
+            uint32_t z = ((uint32_t)(lead  & ~0xF0) << 12) |
+                         ((uint32_t)(cont1 & ~0xC0) <<  6) |
+                          (uint32_t)(cont2 & ~0xC0);
+
+            if (z < 0x800) // overlong sequence
+                return false;
+            if (z >= 0xD800 && z <= 0xDFFF) // surrogate
+                return false;
+
+        // 4-byte sequence
+        } else if ((lead & 0xF8) == 0xF0) {
+            if (count < 4) // truncated sequence
+                return false;
+
+            uint8_t cont1 = str[1];
+            if ((cont1 & 0xC0) != 0x80) // not a continuation byte
+                return false;
+            uint8_t cont2 = str[2];
+            if ((cont2 & 0xC0) != 0x80) // not a continuation byte
+                return false;
+            uint8_t cont3 = str[3];
+            if ((cont3 & 0xC0) != 0x80) // not a continuation byte
+                return false;
+
+            str += 4;
+            count -= 4;
+
+            uint32_t z = ((uint32_t)(lead  & ~0xF8) << 18) |
+                         ((uint32_t)(cont1 & ~0xC0) << 12) |
+                         ((uint32_t)(cont2 & ~0xC0) <<  6) |
+                          (uint32_t)(cont3 & ~0xC0);
+
+            if (z < 0x10000) // overlong sequence
+                return false;
+            if (z > 0x10FFFF) // codepoint limit
+                return false;
+
+        } else {
+            return false; // continuation byte without a lead, or lead for a 5-byte sequence or longer
+        }
+    }
+    return true;
+}
+
+bool mpack_utf8_check(const char* str, size_t bytes) {
+    return mpack_utf8_check_impl((const uint8_t*)str, bytes, true);
+}
+
+bool mpack_utf8_check_no_null(const char* str, size_t bytes) {
+    return mpack_utf8_check_impl((const uint8_t*)str, bytes, false);
+}
+
+bool mpack_str_check_no_null(const char* str, size_t bytes) {
+    for (size_t i = 0; i < bytes; ++i)
+        if (str[i] == '\0')
+            return false;
+    return true;
+}
+
+#if MPACK_DEBUG && MPACK_STDIO
+void mpack_print_append(mpack_print_t* print, const char* data, size_t count) {
+
+    // copy whatever fits into the buffer
+    size_t copy = print->size - print->count;
+    if (copy > count)
+        copy = count;
+    mpack_memcpy(print->buffer + print->count, data, copy);
+    print->count += copy;
+    data += copy;
+    count -= copy;
+
+    // if we don't need to flush or can't flush there's nothing else to do
+    if (count == 0 || print->callback == NULL)
+        return;
+
+    // flush the buffer
+    print->callback(print->context, print->buffer, print->count);
+
+    if (count > print->size / 2) {
+        // flush the rest of the data
+        print->count = 0;
+        print->callback(print->context, data, count);
+    } else {
+        // copy the rest of the data into the buffer
+        mpack_memcpy(print->buffer, data, count);
+        print->count = count;
+    }
+
+}
+
+void mpack_print_flush(mpack_print_t* print) {
+    if (print->count > 0 && print->callback != NULL) {
+        print->callback(print->context, print->buffer, print->count);
+        print->count = 0;
+    }
+}
+
+void mpack_print_file_callback(void* context, const char* data, size_t count) {
+    FILE* file = (FILE*)context;
+    fwrite(data, 1, count, file);
+}
+#endif
+
+/* mpack/mpack-writer.c.c */
+
+#define MPACK_INTERNAL 1
+
+/* #include "mpack-writer.h" */
+
+#if MPACK_WRITER
+
+#if MPACK_WRITE_TRACKING
+static void mpack_writer_flag_if_error(mpack_writer_t* writer, mpack_error_t error) {
+    if (error != mpack_ok)
+        mpack_writer_flag_error(writer, error);
+}
+
+void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count) {
+    if (writer->error == mpack_ok)
+        mpack_writer_flag_if_error(writer, mpack_track_push(&writer->track, type, count));
+}
+
+void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) {
+    if (writer->error == mpack_ok)
+        mpack_writer_flag_if_error(writer, mpack_track_pop(&writer->track, type));
+}
+
+void mpack_writer_track_element(mpack_writer_t* writer) {
+    if (writer->error == mpack_ok)
+        mpack_writer_flag_if_error(writer, mpack_track_element(&writer->track, false));
+}
+
+void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) {
+    if (writer->error == mpack_ok)
+        mpack_writer_flag_if_error(writer, mpack_track_bytes(&writer->track, false, count));
+}
+#endif
+
+static void mpack_writer_clear(mpack_writer_t* writer) {
+    #if MPACK_COMPATIBILITY
+    writer->version = mpack_version_current;
+    #endif
+    writer->flush = NULL;
+    writer->error_fn = NULL;
+    writer->teardown = NULL;
+    writer->context = NULL;
+
+    writer->buffer = NULL;
+    writer->current = NULL;
+    writer->end = NULL;
+    writer->error = mpack_ok;
+
+    #if MPACK_WRITE_TRACKING
+    mpack_memset(&writer->track, 0, sizeof(writer->track));
+    #endif
+}
+
+void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size) {
+    mpack_assert(buffer != NULL, "cannot initialize writer with empty buffer");
+    mpack_writer_clear(writer);
+    writer->buffer = buffer;
+    writer->current = buffer;
+    writer->end = writer->buffer + size;
+
+    #if MPACK_WRITE_TRACKING
+    mpack_writer_flag_if_error(writer, mpack_track_init(&writer->track));
+    #endif
+
+    mpack_log("===========================\n");
+    mpack_log("initializing writer with buffer size %i\n", (int)size);
+}
+
+void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error) {
+    mpack_writer_clear(writer);
+    writer->error = error;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing writer in error state %i\n", (int)error);
+}
+
+void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush) {
+    MPACK_STATIC_ASSERT(MPACK_WRITER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE,
+            "minimum buffer size must fit any tag!");
+    MPACK_STATIC_ASSERT(31 + MPACK_TAG_SIZE_FIXSTR >= MPACK_WRITER_MINIMUM_BUFFER_SIZE,
+            "minimum buffer size must fit the largest possible fixstr!");
+
+    if (mpack_writer_buffer_size(writer) < MPACK_WRITER_MINIMUM_BUFFER_SIZE) {
+        mpack_break("buffer size is %i, but minimum buffer size for flush is %i",
+                (int)mpack_writer_buffer_size(writer), MPACK_WRITER_MINIMUM_BUFFER_SIZE);
+        mpack_writer_flag_error(writer, mpack_error_bug);
+        return;
+    }
+
+    writer->flush = flush;
+}
+
+#ifdef MPACK_MALLOC
+typedef struct mpack_growable_writer_t {
+    char** target_data;
+    size_t* target_size;
+} mpack_growable_writer_t;
+
+static char* mpack_writer_get_reserved(mpack_writer_t* writer) {
+    // This is in a separate function in order to avoid false strict aliasing
+    // warnings. We aren't actually violating strict aliasing (the reserved
+    // space is only ever dereferenced as an mpack_growable_writer_t.)
+    return (char*)writer->reserved;
+}
+
+static void mpack_growable_writer_flush(mpack_writer_t* writer, const char* data, size_t count) {
+
+    // This is an intrusive flush function which modifies the writer's buffer
+    // in response to a flush instead of emptying it in order to add more
+    // capacity for data. This removes the need to copy data from a fixed buffer
+    // into a growable one, improving performance.
+    //
+    // There are three ways flush can be called:
+    //   - flushing the buffer during writing (used is zero, count is all data, data is buffer)
+    //   - flushing extra data during writing (used is all flushed data, count is extra data, data is not buffer)
+    //   - flushing during teardown (used and count are both all flushed data, data is buffer)
+    //
+    // In the first two cases, we grow the buffer by at least double, enough
+    // to ensure that new data will fit. We ignore the teardown flush.
+
+    if (data == writer->buffer) {
+
+        // teardown, do nothing
+        if (mpack_writer_buffer_used(writer) == count)
+            return;
+
+        // otherwise leave the data in the buffer and just grow
+        writer->current = writer->buffer + count;
+        count = 0;
+    }
+
+    size_t used = mpack_writer_buffer_used(writer);
+    size_t size = mpack_writer_buffer_size(writer);
+
+    mpack_log("flush size %i used %i data %p buffer %p\n",
+            (int)count, (int)used, data, writer->buffer);
+
+    mpack_assert(data == writer->buffer || used + count > size,
+            "extra flush for %i but there is %i space left in the buffer! (%i/%i)",
+            (int)count, (int)mpack_writer_buffer_left(writer), (int)used, (int)size);
+
+    // grow to fit the data
+    // TODO: this really needs to correctly test for overflow
+    size_t new_size = size * 2;
+    while (new_size < used + count)
+        new_size *= 2;
+
+    mpack_log("flush growing buffer size from %i to %i\n", (int)size, (int)new_size);
+
+    // grow the buffer
+    char* new_buffer = (char*)mpack_realloc(writer->buffer, used, new_size);
+    if (new_buffer == NULL) {
+        mpack_writer_flag_error(writer, mpack_error_memory);
+        return;
+    }
+    writer->current = new_buffer + used;
+    writer->buffer = new_buffer;
+    writer->end = writer->buffer + new_size;
+
+    // append the extra data
+    if (count > 0) {
+        mpack_memcpy(writer->current, data, count);
+        writer->current += count;
+    }
+
+    mpack_log("new buffer %p, used %i\n", new_buffer, (int)mpack_writer_buffer_used(writer));
+}
+
+static void mpack_growable_writer_teardown(mpack_writer_t* writer) {
+    mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer);
+
+    if (mpack_writer_error(writer) == mpack_ok) {
+
+        // shrink the buffer to an appropriate size if the data is
+        // much smaller than the buffer
+        if (mpack_writer_buffer_used(writer) < mpack_writer_buffer_size(writer) / 2) {
+            size_t used = mpack_writer_buffer_used(writer);
+
+            // We always return a non-null pointer that must be freed, even if
+            // nothing was written. malloc() and realloc() do not necessarily
+            // do this so we enforce it ourselves.
+            size_t size = (used != 0) ? used : 1;
+
+            char* buffer = (char*)mpack_realloc(writer->buffer, used, size);
+            if (!buffer) {
+                MPACK_FREE(writer->buffer);
+                mpack_writer_flag_error(writer, mpack_error_memory);
+                return;
+            }
+            writer->buffer = buffer;
+            writer->end = (writer->current = writer->buffer + used);
+        }
+
+        *growable_writer->target_data = writer->buffer;
+        *growable_writer->target_size = mpack_writer_buffer_used(writer);
+        writer->buffer = NULL;
+
+    } else if (writer->buffer) {
+        MPACK_FREE(writer->buffer);
+        writer->buffer = NULL;
+    }
+
+    writer->context = NULL;
+}
+
+void mpack_writer_init_growable(mpack_writer_t* writer, char** target_data, size_t* target_size) {
+    mpack_assert(target_data != NULL, "cannot initialize writer without a destination for the data");
+    mpack_assert(target_size != NULL, "cannot initialize writer without a destination for the size");
+
+    *target_data = NULL;
+    *target_size = 0;
+
+    MPACK_STATIC_ASSERT(sizeof(mpack_growable_writer_t) <= sizeof(writer->reserved),
+            "not enough reserved space for growable writer!");
+    mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer);
+
+    growable_writer->target_data = target_data;
+    growable_writer->target_size = target_size;
+
+    size_t capacity = MPACK_BUFFER_SIZE;
+    char* buffer = (char*)MPACK_MALLOC(capacity);
+    if (buffer == NULL) {
+        mpack_writer_init_error(writer, mpack_error_memory);
+        return;
+    }
+
+    mpack_writer_init(writer, buffer, capacity);
+    mpack_writer_set_flush(writer, mpack_growable_writer_flush);
+    mpack_writer_set_teardown(writer, mpack_growable_writer_teardown);
+}
+#endif
+
+#if MPACK_STDIO
+static void mpack_file_writer_flush(mpack_writer_t* writer, const char* buffer, size_t count) {
+    FILE* file = (FILE*)writer->context;
+    size_t written = fwrite((const void*)buffer, 1, count, file);
+    if (written != count)
+        mpack_writer_flag_error(writer, mpack_error_io);
+}
+
+static void mpack_file_writer_teardown(mpack_writer_t* writer) {
+    MPACK_FREE(writer->buffer);
+    writer->buffer = NULL;
+    writer->context = NULL;
+}
+
+static void mpack_file_writer_teardown_close(mpack_writer_t* writer) {
+    FILE* file = (FILE*)writer->context;
+
+    if (file) {
+        int ret = fclose(file);
+        if (ret != 0)
+            mpack_writer_flag_error(writer, mpack_error_io);
+    }
+
+    mpack_file_writer_teardown(writer);
+}
+
+void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* file, bool close_when_done) {
+    mpack_assert(file != NULL, "file is NULL");
+
+    size_t capacity = MPACK_BUFFER_SIZE;
+    char* buffer = (char*)MPACK_MALLOC(capacity);
+    if (buffer == NULL) {
+        mpack_writer_init_error(writer, mpack_error_memory);
+        if (close_when_done) {
+            fclose(file);
+        }
+        return;
+    }
+
+    mpack_writer_init(writer, buffer, capacity);
+    mpack_writer_set_context(writer, file);
+    mpack_writer_set_flush(writer, mpack_file_writer_flush);
+    mpack_writer_set_teardown(writer, close_when_done ?
+            mpack_file_writer_teardown_close :
+            mpack_file_writer_teardown);
+}
+
+void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename) {
+    mpack_assert(filename != NULL, "filename is NULL");
+
+    FILE* file = fopen(filename, "wb");
+    if (file == NULL) {
+        mpack_writer_init_error(writer, mpack_error_io);
+        return;
+    }
+
+    mpack_writer_init_stdfile(writer, file, true);
+}
+#endif
+
+void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error) {
+    mpack_log("writer %p setting error %i: %s\n", (void*)writer, (int)error, mpack_error_to_string(error));
+
+    if (writer->error == mpack_ok) {
+        writer->error = error;
+        if (writer->error_fn)
+            writer->error_fn(writer, writer->error);
+    }
+}
+
+MPACK_STATIC_INLINE void mpack_writer_flush_unchecked(mpack_writer_t* writer) {
+    // This is a bit ugly; we reset used before calling flush so that
+    // a flush function can distinguish between flushing the buffer
+    // versus flushing external data. see mpack_growable_writer_flush()
+    size_t used = mpack_writer_buffer_used(writer);
+    writer->current = writer->buffer;
+    writer->flush(writer, writer->buffer, used);
+}
+
+void mpack_writer_flush_message(mpack_writer_t* writer) {
+    if (writer->error != mpack_ok)
+        return;
+
+    #if MPACK_WRITE_TRACKING
+    mpack_writer_flag_if_error(writer, mpack_track_check_empty(&writer->track));
+    if (writer->error != mpack_ok)
+        return;
+    #endif
+
+    if (writer->flush == NULL) {
+        mpack_break("cannot call mpack_writer_flush_message() without a flush function!");
+        mpack_writer_flag_error(writer, mpack_error_bug);
+        return;
+    }
+
+    if (mpack_writer_buffer_used(writer) > 0)
+        mpack_writer_flush_unchecked(writer);
+}
+
+// Ensures there are at least count bytes free in the buffer. This
+// will flag an error if the flush function fails to make enough
+// room in the buffer.
+MPACK_NOINLINE static bool mpack_writer_ensure(mpack_writer_t* writer, size_t count) {
+    mpack_assert(count != 0, "cannot ensure zero bytes!");
+    mpack_assert(count <= MPACK_WRITER_MINIMUM_BUFFER_SIZE,
+            "cannot ensure %i bytes, this is more than the minimum buffer size %i!",
+            (int)count, (int)MPACK_WRITER_MINIMUM_BUFFER_SIZE);
+    mpack_assert(count > mpack_writer_buffer_left(writer),
+            "request to ensure %i bytes but there are already %i left in the buffer!",
+            (int)count, (int)mpack_writer_buffer_left(writer));
+
+    mpack_log("ensuring %i bytes, %i left\n", (int)count, (int)mpack_writer_buffer_left(writer));
+
+    if (mpack_writer_error(writer) != mpack_ok)
+        return false;
+
+    if (writer->flush == NULL) {
+        mpack_writer_flag_error(writer, mpack_error_too_big);
+        return false;
+    }
+
+    mpack_writer_flush_unchecked(writer);
+    if (mpack_writer_error(writer) != mpack_ok)
+        return false;
+
+    if (mpack_writer_buffer_left(writer) >= count)
+        return true;
+
+    mpack_writer_flag_error(writer, mpack_error_io);
+    return false;
+}
+
+// Writes encoded bytes to the buffer when we already know the data
+// does not fit in the buffer (i.e. it straddles the edge of the
+// buffer.) If there is a flush function, it is guaranteed to be
+// called; otherwise mpack_error_too_big is raised.
+MPACK_NOINLINE static void mpack_write_native_straddle(mpack_writer_t* writer, const char* p, size_t count) {
+    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
+
+    if (mpack_writer_error(writer) != mpack_ok)
+        return;
+    mpack_log("big write for %i bytes from %p, %i space left in buffer\n",
+            (int)count, p, (int)mpack_writer_buffer_left(writer));
+    mpack_assert(count > mpack_writer_buffer_left(writer),
+            "big write requested for %i bytes, but there is %i available "
+            "space in buffer. should have called mpack_write_native() instead",
+            (int)count, (int)(mpack_writer_buffer_left(writer)));
+
+    // we'll need a flush function
+    if (!writer->flush) {
+        mpack_writer_flag_error(writer, mpack_error_too_big);
+        return;
+    }
+
+    // flush the buffer
+    mpack_writer_flush_unchecked(writer);
+    if (mpack_writer_error(writer) != mpack_ok)
+        return;
+
+    // note that an intrusive flush function (such as mpack_growable_writer_flush())
+    // may have changed size and/or reset used to a non-zero value. we treat both as
+    // though they may have changed, and there may still be data in the buffer.
+
+    // flush the extra data directly if it doesn't fit in the buffer
+    if (count > mpack_writer_buffer_left(writer)) {
+        writer->flush(writer, p, count);
+        if (mpack_writer_error(writer) != mpack_ok)
+            return;
+    } else {
+        mpack_memcpy(writer->current, p, count);
+        writer->current += count;
+    }
+}
+
+// Writes encoded bytes to the buffer, flushing if necessary.
+MPACK_STATIC_INLINE void mpack_write_native(mpack_writer_t* writer, const char* p, size_t count) {
+    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
+
+    if (mpack_writer_buffer_left(writer) < count) {
+        mpack_write_native_straddle(writer, p, count);
+    } else {
+        mpack_memcpy(writer->current, p, count);
+        writer->current += count;
+    }
+}
+
+mpack_error_t mpack_writer_destroy(mpack_writer_t* writer) {
+
+    // clean up tracking, asserting if we're not already in an error state
+    #if MPACK_WRITE_TRACKING
+    mpack_track_destroy(&writer->track, writer->error != mpack_ok);
+    #endif
+
+    // flush any outstanding data
+    if (mpack_writer_error(writer) == mpack_ok && mpack_writer_buffer_used(writer) != 0 && writer->flush != NULL) {
+        writer->flush(writer, writer->buffer, mpack_writer_buffer_used(writer));
+        writer->flush = NULL;
+    }
+
+    if (writer->teardown) {
+        writer->teardown(writer);
+        writer->teardown = NULL;
+    }
+
+    return writer->error;
+}
+
+void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t value) {
+    switch (value.type) {
+        case mpack_type_missing:
+            mpack_break("cannot write a missing value!");
+            mpack_writer_flag_error(writer, mpack_error_bug);
+            return;
+
+        case mpack_type_nil:    mpack_write_nil   (writer);            return;
+        case mpack_type_bool:   mpack_write_bool  (writer, value.v.b); return;
+        case mpack_type_float:  mpack_write_float (writer, value.v.f); return;
+        case mpack_type_double: mpack_write_double(writer, value.v.d); return;
+        case mpack_type_int:    mpack_write_int   (writer, value.v.i); return;
+        case mpack_type_uint:   mpack_write_uint  (writer, value.v.u); return;
+
+        case mpack_type_str: mpack_start_str(writer, value.v.l); return;
+        case mpack_type_bin: mpack_start_bin(writer, value.v.l); return;
+
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            mpack_start_ext(writer, mpack_tag_ext_exttype(&value), mpack_tag_ext_length(&value));
+            return;
+        #endif
+
+        case mpack_type_array: mpack_start_array(writer, value.v.n); return;
+        case mpack_type_map:   mpack_start_map(writer, value.v.n);   return;
+    }
+
+    mpack_break("unrecognized type %i", (int)value.type);
+    mpack_writer_flag_error(writer, mpack_error_bug);
+}
+
+MPACK_STATIC_INLINE void mpack_write_byte_element(mpack_writer_t* writer, char value) {
+    mpack_writer_track_element(writer);
+    if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= 1) || mpack_writer_ensure(writer, 1))
+        *(writer->current++) = value;
+}
+
+void mpack_write_nil(mpack_writer_t* writer) {
+    mpack_write_byte_element(writer, (char)0xc0);
+}
+
+void mpack_write_bool(mpack_writer_t* writer, bool value) {
+    mpack_write_byte_element(writer, (char)(0xc2 | (value ? 1 : 0)));
+}
+
+void mpack_write_true(mpack_writer_t* writer) {
+    mpack_write_byte_element(writer, (char)0xc3);
+}
+
+void mpack_write_false(mpack_writer_t* writer) {
+    mpack_write_byte_element(writer, (char)0xc2);
+}
+
+void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes) {
+    mpack_writer_track_element(writer);
+    mpack_write_native(writer, data, bytes);
+}
+
+/*
+ * Encode functions
+ */
+
+MPACK_STATIC_INLINE void mpack_encode_fixuint(char* p, uint8_t value) {
+    mpack_assert(value <= 127);
+    mpack_store_u8(p, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_u8(char* p, uint8_t value) {
+    mpack_assert(value > 127);
+    mpack_store_u8(p, 0xcc);
+    mpack_store_u8(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_u16(char* p, uint16_t value) {
+    mpack_assert(value > UINT8_MAX);
+    mpack_store_u8(p, 0xcd);
+    mpack_store_u16(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_u32(char* p, uint32_t value) {
+    mpack_assert(value > UINT16_MAX);
+    mpack_store_u8(p, 0xce);
+    mpack_store_u32(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_u64(char* p, uint64_t value) {
+    mpack_assert(value > UINT32_MAX);
+    mpack_store_u8(p, 0xcf);
+    mpack_store_u64(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixint(char* p, int8_t value) {
+    // this can encode positive or negative fixints
+    mpack_assert(value >= -32);
+    mpack_store_i8(p, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_i8(char* p, int8_t value) {
+    mpack_assert(value < -32);
+    mpack_store_u8(p, 0xd0);
+    mpack_store_i8(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_i16(char* p, int16_t value) {
+    mpack_assert(value < INT8_MIN);
+    mpack_store_u8(p, 0xd1);
+    mpack_store_i16(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_i32(char* p, int32_t value) {
+    mpack_assert(value < INT16_MIN);
+    mpack_store_u8(p, 0xd2);
+    mpack_store_i32(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_i64(char* p, int64_t value) {
+    mpack_assert(value < INT32_MIN);
+    mpack_store_u8(p, 0xd3);
+    mpack_store_i64(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_float(char* p, float value) {
+    mpack_store_u8(p, 0xca);
+    mpack_store_float(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_double(char* p, double value) {
+    mpack_store_u8(p, 0xcb);
+    mpack_store_double(p + 1, value);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixarray(char* p, uint8_t count) {
+    mpack_assert(count <= 15);
+    mpack_store_u8(p, (uint8_t)(0x90 | count));
+}
+
+MPACK_STATIC_INLINE void mpack_encode_array16(char* p, uint16_t count) {
+    mpack_assert(count > 15);
+    mpack_store_u8(p, 0xdc);
+    mpack_store_u16(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_array32(char* p, uint32_t count) {
+    mpack_assert(count > UINT16_MAX);
+    mpack_store_u8(p, 0xdd);
+    mpack_store_u32(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixmap(char* p, uint8_t count) {
+    mpack_assert(count <= 15);
+    mpack_store_u8(p, (uint8_t)(0x80 | count));
+}
+
+MPACK_STATIC_INLINE void mpack_encode_map16(char* p, uint16_t count) {
+    mpack_assert(count > 15);
+    mpack_store_u8(p, 0xde);
+    mpack_store_u16(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_map32(char* p, uint32_t count) {
+    mpack_assert(count > UINT16_MAX);
+    mpack_store_u8(p, 0xdf);
+    mpack_store_u32(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixstr(char* p, uint8_t count) {
+    mpack_assert(count <= 31);
+    mpack_store_u8(p, (uint8_t)(0xa0 | count));
+}
+
+MPACK_STATIC_INLINE void mpack_encode_str8(char* p, uint8_t count) {
+    mpack_assert(count > 31);
+    mpack_store_u8(p, 0xd9);
+    mpack_store_u8(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_str16(char* p, uint16_t count) {
+    // we might be encoding a raw in compatibility mode, so we
+    // allow count to be in the range [32, UINT8_MAX].
+    mpack_assert(count > 31);
+    mpack_store_u8(p, 0xda);
+    mpack_store_u16(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_str32(char* p, uint32_t count) {
+    mpack_assert(count > UINT16_MAX);
+    mpack_store_u8(p, 0xdb);
+    mpack_store_u32(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_bin8(char* p, uint8_t count) {
+    mpack_store_u8(p, 0xc4);
+    mpack_store_u8(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_bin16(char* p, uint16_t count) {
+    mpack_assert(count > UINT8_MAX);
+    mpack_store_u8(p, 0xc5);
+    mpack_store_u16(p + 1, count);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_bin32(char* p, uint32_t count) {
+    mpack_assert(count > UINT16_MAX);
+    mpack_store_u8(p, 0xc6);
+    mpack_store_u32(p + 1, count);
+}
+
+#if MPACK_EXTENSIONS
+MPACK_STATIC_INLINE void mpack_encode_fixext1(char* p, int8_t exttype) {
+    mpack_store_u8(p, 0xd4);
+    mpack_store_i8(p + 1, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixext2(char* p, int8_t exttype) {
+    mpack_store_u8(p, 0xd5);
+    mpack_store_i8(p + 1, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixext4(char* p, int8_t exttype) {
+    mpack_store_u8(p, 0xd6);
+    mpack_store_i8(p + 1, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixext8(char* p, int8_t exttype) {
+    mpack_store_u8(p, 0xd7);
+    mpack_store_i8(p + 1, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_fixext16(char* p, int8_t exttype) {
+    mpack_store_u8(p, 0xd8);
+    mpack_store_i8(p + 1, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_ext8(char* p, int8_t exttype, uint8_t count) {
+    mpack_assert(count != 1 && count != 2 && count != 4 && count != 8 && count != 16);
+    mpack_store_u8(p, 0xc7);
+    mpack_store_u8(p + 1, count);
+    mpack_store_i8(p + 2, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_ext16(char* p, int8_t exttype, uint16_t count) {
+    mpack_assert(count > UINT8_MAX);
+    mpack_store_u8(p, 0xc8);
+    mpack_store_u16(p + 1, count);
+    mpack_store_i8(p + 3, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_ext32(char* p, int8_t exttype, uint32_t count) {
+    mpack_assert(count > UINT16_MAX);
+    mpack_store_u8(p, 0xc9);
+    mpack_store_u32(p + 1, count);
+    mpack_store_i8(p + 5, exttype);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_timestamp_4(char* p, uint32_t seconds) {
+    mpack_encode_fixext4(p, MPACK_EXTTYPE_TIMESTAMP);
+    mpack_store_u32(p + MPACK_TAG_SIZE_FIXEXT4, seconds);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_timestamp_8(char* p, int64_t seconds, uint32_t nanoseconds) {
+    mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX);
+    mpack_encode_fixext8(p, MPACK_EXTTYPE_TIMESTAMP);
+    uint64_t encoded = ((uint64_t)nanoseconds << 34) | (uint64_t)seconds;
+    mpack_store_u64(p + MPACK_TAG_SIZE_FIXEXT8, encoded);
+}
+
+MPACK_STATIC_INLINE void mpack_encode_timestamp_12(char* p, int64_t seconds, uint32_t nanoseconds) {
+    mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX);
+    mpack_encode_ext8(p, MPACK_EXTTYPE_TIMESTAMP, 12);
+    mpack_store_u32(p + MPACK_TAG_SIZE_EXT8, nanoseconds);
+    mpack_store_i64(p + MPACK_TAG_SIZE_EXT8 + 4, seconds);
+}
+#endif
+
+
+
+/*
+ * Write functions
+ */
+
+// This is a macro wrapper to the encode functions to encode
+// directly into the buffer. If mpack_writer_ensure() fails
+// it will flag an error so we don't have to do anything.
+#define MPACK_WRITE_ENCODED(encode_fn, size, ...) do {                                                 \
+    if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) { \
+        MPACK_EXPAND(encode_fn(writer->current, __VA_ARGS__));                                         \
+        writer->current += size;                                                                       \
+    }                                                                                                  \
+} while (0)
+
+void mpack_write_u8(mpack_writer_t* writer, uint8_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_u64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value <= 127) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, value);
+    }
+    #endif
+}
+
+void mpack_write_u16(mpack_writer_t* writer, uint16_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_u64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value <= 127) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
+    } else if (value <= UINT8_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, value);
+    }
+    #endif
+}
+
+void mpack_write_u32(mpack_writer_t* writer, uint32_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_u64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value <= 127) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
+    } else if (value <= UINT8_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+    } else if (value <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, value);
+    }
+    #endif
+}
+
+void mpack_write_u64(mpack_writer_t* writer, uint64_t value) {
+    mpack_writer_track_element(writer);
+
+    if (value <= 127) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
+    } else if (value <= UINT8_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+    } else if (value <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
+    } else if (value <= UINT32_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, value);
+    }
+}
+
+void mpack_write_i8(mpack_writer_t* writer, int8_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_i64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value >= -32) {
+        // we encode positive and negative fixints together
+        MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
+    }
+    #endif
+}
+
+void mpack_write_i16(mpack_writer_t* writer, int16_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_i64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value >= -32) {
+        if (value <= 127) {
+            // we encode positive and negative fixints together
+            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
+        } else if (value <= UINT8_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+        } else {
+            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
+        }
+    } else if (value >= INT8_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
+    }
+    #endif
+}
+
+void mpack_write_i32(mpack_writer_t* writer, int32_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_write_i64(writer, value);
+    #else
+    mpack_writer_track_element(writer);
+    if (value >= -32) {
+        if (value <= 127) {
+            // we encode positive and negative fixints together
+            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
+        } else if (value <= UINT8_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+        } else if (value <= UINT16_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
+        } else {
+            MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
+        }
+    } else if (value >= INT8_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
+    } else if (value >= INT16_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, value);
+    }
+    #endif
+}
+
+void mpack_write_i64(mpack_writer_t* writer, int64_t value) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    if (value > 127) {
+        // for non-fix positive ints we call the u64 writer to save space
+        mpack_write_u64(writer, (uint64_t)value);
+        return;
+    }
+    #endif
+
+    mpack_writer_track_element(writer);
+    if (value >= -32) {
+        #if MPACK_OPTIMIZE_FOR_SIZE
+        MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
+        #else
+        if (value <= 127) {
+            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
+        } else if (value <= UINT8_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
+        } else if (value <= UINT16_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
+        } else if (value <= UINT32_MAX) {
+            MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
+        } else {
+            MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, (uint64_t)value);
+        }
+        #endif
+    } else if (value >= INT8_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
+    } else if (value >= INT16_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
+    } else if (value >= INT32_MIN) {
+        MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, (int32_t)value);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_i64, MPACK_TAG_SIZE_I64, value);
+    }
+}
+
+void mpack_write_float(mpack_writer_t* writer, float value) {
+    mpack_writer_track_element(writer);
+    MPACK_WRITE_ENCODED(mpack_encode_float, MPACK_TAG_SIZE_FLOAT, value);
+}
+
+void mpack_write_double(mpack_writer_t* writer, double value) {
+    mpack_writer_track_element(writer);
+    MPACK_WRITE_ENCODED(mpack_encode_double, MPACK_TAG_SIZE_DOUBLE, value);
+}
+
+#if MPACK_EXTENSIONS
+void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds) {
+    #if MPACK_COMPATIBILITY
+    if (writer->version <= mpack_version_v4) {
+        mpack_break("Timestamps require spec version v5 or later. This writer is in v%i mode.", (int)writer->version);
+        mpack_writer_flag_error(writer, mpack_error_bug);
+        return;
+    }
+    #endif
+
+    if (nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
+        mpack_break("timestamp nanoseconds out of bounds: %u", nanoseconds);
+        mpack_writer_flag_error(writer, mpack_error_bug);
+        return;
+    }
+
+    mpack_writer_track_element(writer);
+
+    if (seconds < 0 || seconds >= (INT64_C(1) << 34)) {
+        MPACK_WRITE_ENCODED(mpack_encode_timestamp_12, MPACK_EXT_SIZE_TIMESTAMP12, seconds, nanoseconds);
+    } else if (seconds > UINT32_MAX || nanoseconds > 0) {
+        MPACK_WRITE_ENCODED(mpack_encode_timestamp_8, MPACK_EXT_SIZE_TIMESTAMP8, seconds, nanoseconds);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_timestamp_4, MPACK_EXT_SIZE_TIMESTAMP4, (uint32_t)seconds);
+    }
+}
+#endif
+
+void mpack_start_array(mpack_writer_t* writer, uint32_t count) {
+    mpack_writer_track_element(writer);
+
+    if (count <= 15) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixarray, MPACK_TAG_SIZE_FIXARRAY, (uint8_t)count);
+    } else if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_array16, MPACK_TAG_SIZE_ARRAY16, (uint16_t)count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_array32, MPACK_TAG_SIZE_ARRAY32, (uint32_t)count);
+    }
+
+    mpack_writer_track_push(writer, mpack_type_array, count);
+}
+
+void mpack_start_map(mpack_writer_t* writer, uint32_t count) {
+    mpack_writer_track_element(writer);
+
+    if (count <= 15) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixmap, MPACK_TAG_SIZE_FIXMAP, (uint8_t)count);
+    } else if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_map16, MPACK_TAG_SIZE_MAP16, (uint16_t)count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_map32, MPACK_TAG_SIZE_MAP32, (uint32_t)count);
+    }
+
+    mpack_writer_track_push(writer, mpack_type_map, count);
+}
+
+static void mpack_start_str_notrack(mpack_writer_t* writer, uint32_t count) {
+    if (count <= 31) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixstr, MPACK_TAG_SIZE_FIXSTR, (uint8_t)count);
+
+    // str8 is only supported in v5 or later.
+    } else if (count <= UINT8_MAX
+            #if MPACK_COMPATIBILITY
+            && writer->version >= mpack_version_v5
+            #endif
+            ) {
+        MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count);
+
+    } else if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count);
+    }
+}
+
+static void mpack_start_bin_notrack(mpack_writer_t* writer, uint32_t count) {
+    #if MPACK_COMPATIBILITY
+    // In the v4 spec, there was only the raw type for any kind of
+    // variable-length data. In v4 mode, we support the bin functions,
+    // but we produce an old-style raw.
+    if (writer->version <= mpack_version_v4) {
+        mpack_start_str_notrack(writer, count);
+        return;
+    }
+    #endif
+
+    if (count <= UINT8_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_bin8, MPACK_TAG_SIZE_BIN8, (uint8_t)count);
+    } else if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_bin16, MPACK_TAG_SIZE_BIN16, (uint16_t)count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_bin32, MPACK_TAG_SIZE_BIN32, (uint32_t)count);
+    }
+}
+
+void mpack_start_str(mpack_writer_t* writer, uint32_t count) {
+    mpack_writer_track_element(writer);
+    mpack_start_str_notrack(writer, count);
+    mpack_writer_track_push(writer, mpack_type_str, count);
+}
+
+void mpack_start_bin(mpack_writer_t* writer, uint32_t count) {
+    mpack_writer_track_element(writer);
+    mpack_start_bin_notrack(writer, count);
+    mpack_writer_track_push(writer, mpack_type_bin, count);
+}
+
+#if MPACK_EXTENSIONS
+void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count) {
+    #if MPACK_COMPATIBILITY
+    if (writer->version <= mpack_version_v4) {
+        mpack_break("Ext types require spec version v5 or later. This writer is in v%i mode.", (int)writer->version);
+        mpack_writer_flag_error(writer, mpack_error_bug);
+        return;
+    }
+    #endif
+
+    mpack_writer_track_element(writer);
+
+    if (count == 1) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixext1, MPACK_TAG_SIZE_FIXEXT1, exttype);
+    } else if (count == 2) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixext2, MPACK_TAG_SIZE_FIXEXT2, exttype);
+    } else if (count == 4) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixext4, MPACK_TAG_SIZE_FIXEXT4, exttype);
+    } else if (count == 8) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixext8, MPACK_TAG_SIZE_FIXEXT8, exttype);
+    } else if (count == 16) {
+        MPACK_WRITE_ENCODED(mpack_encode_fixext16, MPACK_TAG_SIZE_FIXEXT16, exttype);
+    } else if (count <= UINT8_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_ext8, MPACK_TAG_SIZE_EXT8, exttype, (uint8_t)count);
+    } else if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_ext16, MPACK_TAG_SIZE_EXT16, exttype, (uint16_t)count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_ext32, MPACK_TAG_SIZE_EXT32, exttype, (uint32_t)count);
+    }
+
+    mpack_writer_track_push(writer, mpack_type_ext, count);
+}
+#endif
+
+
+
+/*
+ * Compound helpers and other functions
+ */
+
+void mpack_write_str(mpack_writer_t* writer, const char* data, uint32_t count) {
+    mpack_assert(data != NULL, "data for string of length %i is NULL", (int)count);
+
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_writer_track_element(writer);
+    mpack_start_str_notrack(writer, count);
+    mpack_write_native(writer, data, count);
+    #else
+
+    mpack_writer_track_element(writer);
+
+    if (count <= 31) {
+        // The minimum buffer size when using a flush function is guaranteed to
+        // fit the largest possible fixstr.
+        size_t size = count + MPACK_TAG_SIZE_FIXSTR;
+        if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) {
+            char* MPACK_RESTRICT p = writer->current;
+            mpack_encode_fixstr(p, (uint8_t)count);
+            mpack_memcpy(p + MPACK_TAG_SIZE_FIXSTR, data, count);
+            writer->current += count + MPACK_TAG_SIZE_FIXSTR;
+        }
+        return;
+    }
+
+    if (count <= UINT8_MAX
+            #if MPACK_COMPATIBILITY
+            && writer->version >= mpack_version_v5
+            #endif
+            ) {
+        if (count + MPACK_TAG_SIZE_STR8 <= mpack_writer_buffer_left(writer)) {
+            char* MPACK_RESTRICT p = writer->current;
+            mpack_encode_str8(p, (uint8_t)count);
+            mpack_memcpy(p + MPACK_TAG_SIZE_STR8, data, count);
+            writer->current += count + MPACK_TAG_SIZE_STR8;
+        } else {
+            MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count);
+            mpack_write_native(writer, data, count);
+        }
+        return;
+    }
+
+    // str16 and str32 are likely to be a significant fraction of the buffer
+    // size, so we don't bother with a combined space check in order to
+    // minimize code size.
+    if (count <= UINT16_MAX) {
+        MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count);
+        mpack_write_native(writer, data, count);
+    } else {
+        MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count);
+        mpack_write_native(writer, data, count);
+    }
+
+    #endif
+}
+
+void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count) {
+    mpack_assert(data != NULL, "data pointer for bin of %i bytes is NULL", (int)count);
+    mpack_start_bin(writer, count);
+    mpack_write_bytes(writer, data, count);
+    mpack_finish_bin(writer);
+}
+
+#if MPACK_EXTENSIONS
+void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count) {
+    mpack_assert(data != NULL, "data pointer for ext of type %i and %i bytes is NULL", exttype, (int)count);
+    mpack_start_ext(writer, exttype, count);
+    mpack_write_bytes(writer, data, count);
+    mpack_finish_ext(writer);
+}
+#endif
+
+void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count) {
+    mpack_assert(data != NULL, "data pointer for %i bytes is NULL", (int)count);
+    mpack_writer_track_bytes(writer, count);
+    mpack_write_native(writer, data, count);
+}
+
+void mpack_write_cstr(mpack_writer_t* writer, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr pointer is NULL");
+    size_t length = mpack_strlen(cstr);
+    if (length > UINT32_MAX)
+        mpack_writer_flag_error(writer, mpack_error_invalid);
+    mpack_write_str(writer, cstr, (uint32_t)length);
+}
+
+void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr) {
+    if (cstr)
+        mpack_write_cstr(writer, cstr);
+    else
+        mpack_write_nil(writer);
+}
+
+void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length) {
+    mpack_assert(str != NULL, "data for string of length %i is NULL", (int)length);
+    if (!mpack_utf8_check(str, length)) {
+        mpack_writer_flag_error(writer, mpack_error_invalid);
+        return;
+    }
+    mpack_write_str(writer, str, length);
+}
+
+void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr pointer is NULL");
+    size_t length = mpack_strlen(cstr);
+    if (length > UINT32_MAX) {
+        mpack_writer_flag_error(writer, mpack_error_invalid);
+        return;
+    }
+    mpack_write_utf8(writer, cstr, (uint32_t)length);
+}
+
+void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr) {
+    if (cstr)
+        mpack_write_utf8_cstr(writer, cstr);
+    else
+        mpack_write_nil(writer);
+}
+
+#endif
+
+
+/* mpack/mpack-reader.c.c */
+
+#define MPACK_INTERNAL 1
+
+/* #include "mpack-reader.h" */
+
+#if MPACK_READER
+
+static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count);
+
+void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count) {
+    mpack_assert(buffer != NULL, "buffer is NULL");
+
+    mpack_memset(reader, 0, sizeof(*reader));
+    reader->buffer = buffer;
+    reader->size = size;
+    reader->data = buffer;
+    reader->end = buffer + count;
+
+    #if MPACK_READ_TRACKING
+    mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track));
+    #endif
+
+    mpack_log("===========================\n");
+    mpack_log("initializing reader with buffer size %i\n", (int)size);
+}
+
+void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error) {
+    mpack_memset(reader, 0, sizeof(*reader));
+    reader->error = error;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing reader error state %i\n", (int)error);
+}
+
+void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count) {
+    mpack_assert(data != NULL, "data is NULL");
+
+    mpack_memset(reader, 0, sizeof(*reader));
+    reader->data = data;
+    reader->end = data + count;
+
+    #if MPACK_READ_TRACKING
+    mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track));
+    #endif
+
+    mpack_log("===========================\n");
+    mpack_log("initializing reader with data size %i\n", (int)count);
+}
+
+void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill) {
+    MPACK_STATIC_ASSERT(MPACK_READER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE,
+            "minimum buffer size must fit any tag!");
+
+    if (reader->size == 0) {
+        mpack_break("cannot use fill function without a writeable buffer!");
+        mpack_reader_flag_error(reader, mpack_error_bug);
+        return;
+    }
+
+    if (reader->size < MPACK_READER_MINIMUM_BUFFER_SIZE) {
+        mpack_break("buffer size is %i, but minimum buffer size for fill is %i",
+                (int)reader->size, MPACK_READER_MINIMUM_BUFFER_SIZE);
+        mpack_reader_flag_error(reader, mpack_error_bug);
+        return;
+    }
+
+    reader->fill = fill;
+}
+
+void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip) {
+    mpack_assert(reader->size != 0, "cannot use skip function without a writeable buffer!");
+    reader->skip = skip;
+}
+
+#if MPACK_STDIO
+static size_t mpack_file_reader_fill(mpack_reader_t* reader, char* buffer, size_t count) {
+    if (feof((FILE *)reader->context)) {
+       mpack_reader_flag_error(reader, mpack_error_eof);
+       return 0;
+    }
+    return fread((void*)buffer, 1, count, (FILE*)reader->context);
+}
+
+static void mpack_file_reader_skip(mpack_reader_t* reader, size_t count) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return;
+    FILE* file = (FILE*)reader->context;
+
+    // We call ftell() to test whether the stream is seekable
+    // without causing a file error.
+    if (ftell(file) >= 0) {
+        mpack_log("seeking forward %i bytes\n", (int)count);
+        if (fseek(file, (long int)count, SEEK_CUR) == 0)
+            return;
+        mpack_log("fseek() didn't return zero!\n");
+        if (ferror(file)) {
+            mpack_reader_flag_error(reader, mpack_error_io);
+            return;
+        }
+    }
+
+    // If the stream is not seekable, fall back to the fill function.
+    mpack_reader_skip_using_fill(reader, count);
+}
+
+static void mpack_file_reader_teardown(mpack_reader_t* reader) {
+    MPACK_FREE(reader->buffer);
+    reader->buffer = NULL;
+    reader->context = NULL;
+    reader->size = 0;
+    reader->fill = NULL;
+    reader->skip = NULL;
+    reader->teardown = NULL;
+}
+
+static void mpack_file_reader_teardown_close(mpack_reader_t* reader) {
+    FILE* file = (FILE*)reader->context;
+
+    if (file) {
+        int ret = fclose(file);
+        if (ret != 0)
+            mpack_reader_flag_error(reader, mpack_error_io);
+    }
+
+    mpack_file_reader_teardown(reader);
+}
+
+void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* file, bool close_when_done) {
+    mpack_assert(file != NULL, "file is NULL");
+
+    size_t capacity = MPACK_BUFFER_SIZE;
+    char* buffer = (char*)MPACK_MALLOC(capacity);
+    if (buffer == NULL) {
+        mpack_reader_init_error(reader, mpack_error_memory);
+        if (close_when_done) {
+            fclose(file);
+        }
+        return;
+    }
+
+    mpack_reader_init(reader, buffer, capacity, 0);
+    mpack_reader_set_context(reader, file);
+    mpack_reader_set_fill(reader, mpack_file_reader_fill);
+    mpack_reader_set_skip(reader, mpack_file_reader_skip);
+    mpack_reader_set_teardown(reader, close_when_done ?
+            mpack_file_reader_teardown_close :
+            mpack_file_reader_teardown);
+}
+
+void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename) {
+    mpack_assert(filename != NULL, "filename is NULL");
+
+    FILE* file = fopen(filename, "rb");
+    if (file == NULL) {
+        mpack_reader_init_error(reader, mpack_error_io);
+        return;
+    }
+
+    mpack_reader_init_stdfile(reader, file, true);
+}
+#endif
+
+mpack_error_t mpack_reader_destroy(mpack_reader_t* reader) {
+
+    // clean up tracking, asserting if we're not already in an error state
+    #if MPACK_READ_TRACKING
+    mpack_reader_flag_if_error(reader, mpack_track_destroy(&reader->track, mpack_reader_error(reader) != mpack_ok));
+    #endif
+
+    if (reader->teardown)
+        reader->teardown(reader);
+    reader->teardown = NULL;
+
+    return reader->error;
+}
+
+size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return 0;
+
+    #if MPACK_READ_TRACKING
+    if (mpack_reader_flag_if_error(reader, mpack_track_check_empty(&reader->track)) != mpack_ok)
+        return 0;
+    #endif
+
+    if (data)
+        *data = reader->data;
+    return (size_t)(reader->end - reader->data);
+}
+
+void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error) {
+    mpack_log("reader %p setting error %i: %s\n", (void*)reader, (int)error, mpack_error_to_string(error));
+
+    if (reader->error == mpack_ok) {
+        reader->error = error;
+        reader->end = reader->data;
+        if (reader->error_fn)
+            reader->error_fn(reader, error);
+    }
+}
+
+// Loops on the fill function, reading between the minimum and
+// maximum number of bytes and flagging an error if it fails.
+MPACK_NOINLINE static size_t mpack_fill_range(mpack_reader_t* reader, char* p, size_t min_bytes, size_t max_bytes) {
+    mpack_assert(reader->fill != NULL, "mpack_fill_range() called with no fill function?");
+    mpack_assert(min_bytes > 0, "cannot fill zero bytes!");
+    mpack_assert(max_bytes >= min_bytes, "min_bytes %i cannot be larger than max_bytes %i!",
+            (int)min_bytes, (int)max_bytes);
+
+    size_t count = 0;
+    while (count < min_bytes) {
+        size_t read = reader->fill(reader, p + count, max_bytes - count);
+
+        // Reader fill functions can flag an error or return 0 on failure. We
+        // also guard against functions that return -1 just in case.
+        if (mpack_reader_error(reader) != mpack_ok)
+            return 0;
+        if (read == 0 || read == ((size_t)(-1))) {
+            mpack_reader_flag_error(reader, mpack_error_io);
+            return 0;
+        }
+
+        count += read;
+    }
+    return count;
+}
+
+MPACK_NOINLINE bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count) {
+    mpack_assert(count != 0, "cannot ensure zero bytes!");
+    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
+
+    mpack_assert(count > (size_t)(reader->end - reader->data),
+            "straddling ensure requested for %i bytes, but there are %i bytes "
+            "left in buffer. call mpack_reader_ensure() instead",
+            (int)count, (int)(reader->end - reader->data));
+
+    // we'll need a fill function to get more data. if there's no
+    // fill function, the buffer should contain an entire MessagePack
+    // object, so we raise mpack_error_invalid instead of mpack_error_io
+    // on truncated data.
+    if (reader->fill == NULL) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        return false;
+    }
+
+    // we need enough space in the buffer. if the buffer is not
+    // big enough, we return mpack_error_too_big (since this is
+    // for an in-place read larger than the buffer size.)
+    if (count > reader->size) {
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        return false;
+    }
+
+    // move the existing data to the start of the buffer
+    size_t left = (size_t)(reader->end - reader->data);
+    mpack_memmove(reader->buffer, reader->data, left);
+    reader->end -= reader->data - reader->buffer;
+    reader->data = reader->buffer;
+
+    // read at least the necessary number of bytes, accepting up to the
+    // buffer size
+    size_t read = mpack_fill_range(reader, reader->buffer + left,
+            count - left, reader->size - left);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return false;
+    reader->end += read;
+    return true;
+}
+
+// Reads count bytes into p. Used when there are not enough bytes
+// left in the buffer to satisfy a read.
+MPACK_NOINLINE void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count) {
+    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        mpack_memset(p, 0, count);
+        return;
+    }
+
+    size_t left = (size_t)(reader->end - reader->data);
+    mpack_log("big read for %i bytes into %p, %i left in buffer, buffer size %i\n",
+            (int)count, p, (int)left, (int)reader->size);
+
+    if (count <= left) {
+        mpack_assert(0,
+                "big read requested for %i bytes, but there are %i bytes "
+                "left in buffer. call mpack_read_native() instead",
+                (int)count, (int)left);
+        mpack_reader_flag_error(reader, mpack_error_bug);
+        mpack_memset(p, 0, count);
+        return;
+    }
+
+    // we'll need a fill function to get more data. if there's no
+    // fill function, the buffer should contain an entire MessagePack
+    // object, so we raise mpack_error_invalid instead of mpack_error_io
+    // on truncated data.
+    if (reader->fill == NULL) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        mpack_memset(p, 0, count);
+        return;
+    }
+
+    if (reader->size == 0) {
+        // somewhat debatable what error should be returned here. when
+        // initializing a reader with an in-memory buffer it's not
+        // necessarily a bug if the data is blank; it might just have
+        // been truncated to zero. for this reason we return the same
+        // error as if the data was truncated.
+        mpack_reader_flag_error(reader, mpack_error_io);
+        mpack_memset(p, 0, count);
+        return;
+    }
+
+    // flush what's left of the buffer
+    if (left > 0) {
+        mpack_log("flushing %i bytes remaining in buffer\n", (int)left);
+        mpack_memcpy(p, reader->data, left);
+        count -= left;
+        p += left;
+        reader->data += left;
+    }
+
+    // if the remaining data needed is some small fraction of the
+    // buffer size, we'll try to fill the buffer as much as possible
+    // and copy the needed data out.
+    if (count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR) {
+        size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size);
+        if (mpack_reader_error(reader) != mpack_ok)
+            return;
+        mpack_memcpy(p, reader->buffer, count);
+        reader->data = reader->buffer + count;
+        reader->end = reader->buffer + read;
+
+    // otherwise we read the remaining data directly into the target.
+    } else {
+        mpack_log("reading %i additional bytes\n", (int)count);
+        mpack_fill_range(reader, p, count, count);
+    }
+}
+
+MPACK_NOINLINE static void mpack_skip_bytes_straddle(mpack_reader_t* reader, size_t count) {
+
+    // we'll need at least a fill function to skip more data. if there's
+    // no fill function, the buffer should contain an entire MessagePack
+    // object, so we raise mpack_error_invalid instead of mpack_error_io
+    // on truncated data. (see mpack_read_native_straddle())
+    if (reader->fill == NULL) {
+        mpack_log("reader has no fill function!\n");
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        return;
+    }
+
+    // discard whatever's left in the buffer
+    size_t left = (size_t)(reader->end - reader->data);
+    mpack_log("discarding %i bytes still in buffer\n", (int)left);
+    count -= left;
+    reader->data = reader->end;
+
+    // use the skip function if we've got one, and if we're trying
+    // to skip a lot of data. if we only need to skip some tiny
+    // fraction of the buffer size, it's probably better to just
+    // fill the buffer and skip from it instead of trying to seek.
+    if (reader->skip && count > reader->size / 16) {
+        mpack_log("calling skip function for %i bytes\n", (int)count);
+        reader->skip(reader, count);
+        return;
+    }
+
+    mpack_reader_skip_using_fill(reader, count);
+}
+
+void mpack_skip_bytes(mpack_reader_t* reader, size_t count) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return;
+    mpack_log("skip requested for %i bytes\n", (int)count);
+
+    mpack_reader_track_bytes(reader, count);
+
+    // check if we have enough in the buffer already
+    size_t left = (size_t)(reader->end - reader->data);
+    if (left >= count) {
+        mpack_log("skipping %u bytes still in buffer\n", (uint32_t)count);
+        reader->data += count;
+        return;
+    }
+
+    mpack_skip_bytes_straddle(reader, count);
+}
+
+MPACK_NOINLINE static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count) {
+    mpack_assert(reader->fill != NULL, "missing fill function!");
+    mpack_assert(reader->data == reader->end, "there are bytes left in the buffer!");
+    mpack_assert(reader->error == mpack_ok, "should not have called this in an error state (%i)", reader->error);
+    mpack_log("skip using fill for %i bytes\n", (int)count);
+
+    // fill and discard multiples of the buffer size
+    while (count > reader->size) {
+        mpack_log("filling and discarding buffer of %i bytes\n", (int)reader->size);
+        if (mpack_fill_range(reader, reader->buffer, reader->size, reader->size) < reader->size) {
+            mpack_reader_flag_error(reader, mpack_error_io);
+            return;
+        }
+        count -= reader->size;
+    }
+
+    // fill the buffer as much as possible
+    reader->data = reader->buffer;
+    size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size);
+    if (read < count) {
+        mpack_reader_flag_error(reader, mpack_error_io);
+        return;
+    }
+    reader->end = reader->data + read;
+    mpack_log("filled %i bytes into buffer; discarding %i bytes\n", (int)read, (int)count);
+    reader->data += count;
+}
+
+void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count) {
+    mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)count);
+    mpack_reader_track_bytes(reader, count);
+    mpack_read_native(reader, p, count);
+}
+
+void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count) {
+    mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)byte_count);
+    mpack_reader_track_str_bytes_all(reader, byte_count);
+    mpack_read_native(reader, p, byte_count);
+
+    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(p, byte_count))
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+static void mpack_read_cstr_unchecked(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
+    mpack_assert(buf != NULL, "destination for read of %i bytes is NULL", (int)byte_count);
+    mpack_assert(buffer_size >= 1, "buffer size is zero; you must have room for at least a null-terminator");
+
+    if (mpack_reader_error(reader)) {
+        buf[0] = 0;
+        return;
+    }
+
+    if (byte_count > buffer_size - 1) {
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        buf[0] = 0;
+        return;
+    }
+
+    mpack_reader_track_str_bytes_all(reader, byte_count);
+    mpack_read_native(reader, buf, byte_count);
+    buf[byte_count] = 0;
+}
+
+void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
+    mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count);
+
+    // check for null bytes
+    if (mpack_reader_error(reader) == mpack_ok && !mpack_str_check_no_null(buf, byte_count)) {
+        buf[0] = 0;
+        mpack_reader_flag_error(reader, mpack_error_type);
+    }
+}
+
+void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
+    mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count);
+
+    // check encoding
+    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check_no_null(buf, byte_count)) {
+        buf[0] = 0;
+        mpack_reader_flag_error(reader, mpack_error_type);
+    }
+}
+
+#ifdef MPACK_MALLOC
+// Reads native bytes with error callback disabled. This allows MPack reader functions
+// to hold an allocated buffer and read native data into it without leaking it in
+// case of a non-local jump (longjmp, throw) out of an error handler.
+static void mpack_read_native_noerrorfn(mpack_reader_t* reader, char* p, size_t count) {
+    mpack_assert(reader->error == mpack_ok, "cannot call if an error is already flagged!");
+    mpack_reader_error_t error_fn = reader->error_fn;
+    reader->error_fn = NULL;
+    mpack_read_native(reader, p, count);
+    reader->error_fn = error_fn;
+}
+
+char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated) {
+
+    // track the bytes first in case it jumps
+    mpack_reader_track_bytes(reader, count);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return NULL;
+
+    // cannot allocate zero bytes. this is not an error.
+    if (count == 0 && null_terminated == false)
+        return NULL;
+
+    // allocate data
+    char* data = (char*)MPACK_MALLOC(count + (null_terminated ? 1 : 0)); // TODO: can this overflow?
+    if (data == NULL) {
+        mpack_reader_flag_error(reader, mpack_error_memory);
+        return NULL;
+    }
+
+    // read with error callback disabled so we don't leak our buffer
+    mpack_read_native_noerrorfn(reader, data, count);
+
+    // report flagged errors
+    if (mpack_reader_error(reader) != mpack_ok) {
+        MPACK_FREE(data);
+        if (reader->error_fn)
+            reader->error_fn(reader, mpack_reader_error(reader));
+        return NULL;
+    }
+
+    if (null_terminated)
+        data[count] = '\0';
+    return data;
+}
+#endif
+
+// read inplace without tracking (since there are different
+// tracking modes for different inplace readers)
+static const char* mpack_read_bytes_inplace_notrack(mpack_reader_t* reader, size_t count) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return NULL;
+
+    // if we have enough bytes already in the buffer, we can return it directly.
+    if ((size_t)(reader->end - reader->data) >= count) {
+        const char* bytes = reader->data;
+        reader->data += count;
+        return bytes;
+    }
+
+    if (!mpack_reader_ensure(reader, count))
+        return NULL;
+
+    const char* bytes = reader->data;
+    reader->data += count;
+    return bytes;
+}
+
+const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count) {
+    mpack_reader_track_bytes(reader, count);
+    return mpack_read_bytes_inplace_notrack(reader, count);
+}
+
+const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count) {
+    mpack_reader_track_str_bytes_all(reader, count);
+    const char* str = mpack_read_bytes_inplace_notrack(reader, count);
+
+    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(str, count)) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return NULL;
+    }
+
+    return str;
+}
+
+static size_t mpack_parse_tag(mpack_reader_t* reader, mpack_tag_t* tag) {
+    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
+
+    if (!mpack_reader_ensure(reader, 1))
+        return 0;
+    uint8_t type = mpack_load_u8(reader->data);
+
+    // unfortunately, by far the fastest way to parse a tag is to switch
+    // on the first byte, and to explicitly list every possible byte. so for
+    // infix types, the list of cases is quite large.
+    //
+    // in size-optimized builds, we switch on the top four bits first to
+    // handle most infix types with a smaller jump table to save space.
+
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    switch (type >> 4) {
+
+        // positive fixnum
+        case 0x0: case 0x1: case 0x2: case 0x3:
+        case 0x4: case 0x5: case 0x6: case 0x7:
+            *tag = mpack_tag_make_uint(type);
+            return 1;
+
+        // negative fixnum
+        case 0xe: case 0xf:
+            *tag = mpack_tag_make_int((int8_t)type);
+            return 1;
+
+        // fixmap
+        case 0x8:
+            *tag = mpack_tag_make_map(type & ~0xf0u);
+            return 1;
+
+        // fixarray
+        case 0x9:
+            *tag = mpack_tag_make_array(type & ~0xf0u);
+            return 1;
+
+        // fixstr
+        case 0xa: case 0xb:
+            *tag = mpack_tag_make_str(type & ~0xe0u);
+            return 1;
+
+        // not one of the common infix types
+        default:
+            break;
+
+    }
+    #endif
+
+    // handle individual type tags
+    switch (type) {
+
+        #if !MPACK_OPTIMIZE_FOR_SIZE
+        // positive fixnum
+        case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
+        case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+        case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
+        case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+        case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
+        case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+        case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
+        case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+        case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
+        case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
+        case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57:
+        case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f:
+        case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
+        case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+        case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77:
+        case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+            *tag = mpack_tag_make_uint(type);
+            return 1;
+
+        // negative fixnum
+        case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+        case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
+        case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+        case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff:
+            *tag = mpack_tag_make_int((int8_t)type);
+            return 1;
+
+        // fixmap
+        case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
+        case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+            *tag = mpack_tag_make_map(type & ~0xf0u);
+            return 1;
+
+        // fixarray
+        case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
+        case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+            *tag = mpack_tag_make_array(type & ~0xf0u);
+            return 1;
+
+        // fixstr
+        case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+        case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf:
+        case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+        case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+            *tag = mpack_tag_make_str(type & ~0xe0u);
+            return 1;
+        #endif
+
+        // nil
+        case 0xc0:
+            *tag = mpack_tag_make_nil();
+            return 1;
+
+        // bool
+        case 0xc2: case 0xc3:
+            *tag = mpack_tag_make_bool((bool)(type & 1));
+            return 1;
+
+        // bin8
+        case 0xc4:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN8))
+                return 0;
+            *tag = mpack_tag_make_bin(mpack_load_u8(reader->data + 1));
+            return MPACK_TAG_SIZE_BIN8;
+
+        // bin16
+        case 0xc5:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN16))
+                return 0;
+            *tag = mpack_tag_make_bin(mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_BIN16;
+
+        // bin32
+        case 0xc6:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN32))
+                return 0;
+            *tag = mpack_tag_make_bin(mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_BIN32;
+
+        #if MPACK_EXTENSIONS
+        // ext8
+        case 0xc7:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT8))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 2), mpack_load_u8(reader->data + 1));
+            return MPACK_TAG_SIZE_EXT8;
+
+        // ext16
+        case 0xc8:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT16))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 3), mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_EXT16;
+
+        // ext32
+        case 0xc9:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT32))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 5), mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_EXT32;
+        #endif
+
+        // float
+        case 0xca:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FLOAT))
+                return 0;
+            *tag = mpack_tag_make_float(mpack_load_float(reader->data + 1));
+            return MPACK_TAG_SIZE_FLOAT;
+
+        // double
+        case 0xcb:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_DOUBLE))
+                return 0;
+            *tag = mpack_tag_make_double(mpack_load_double(reader->data + 1));
+            return MPACK_TAG_SIZE_DOUBLE;
+
+        // uint8
+        case 0xcc:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U8))
+                return 0;
+            *tag = mpack_tag_make_uint(mpack_load_u8(reader->data + 1));
+            return MPACK_TAG_SIZE_U8;
+
+        // uint16
+        case 0xcd:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U16))
+                return 0;
+            *tag = mpack_tag_make_uint(mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_U16;
+
+        // uint32
+        case 0xce:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U32))
+                return 0;
+            *tag = mpack_tag_make_uint(mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_U32;
+
+        // uint64
+        case 0xcf:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U64))
+                return 0;
+            *tag = mpack_tag_make_uint(mpack_load_u64(reader->data + 1));
+            return MPACK_TAG_SIZE_U64;
+
+        // int8
+        case 0xd0:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I8))
+                return 0;
+            *tag = mpack_tag_make_int(mpack_load_i8(reader->data + 1));
+            return MPACK_TAG_SIZE_I8;
+
+        // int16
+        case 0xd1:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I16))
+                return 0;
+            *tag = mpack_tag_make_int(mpack_load_i16(reader->data + 1));
+            return MPACK_TAG_SIZE_I16;
+
+        // int32
+        case 0xd2:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I32))
+                return 0;
+            *tag = mpack_tag_make_int(mpack_load_i32(reader->data + 1));
+            return MPACK_TAG_SIZE_I32;
+
+        // int64
+        case 0xd3:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I64))
+                return 0;
+            *tag = mpack_tag_make_int(mpack_load_i64(reader->data + 1));
+            return MPACK_TAG_SIZE_I64;
+
+        #if MPACK_EXTENSIONS
+        // fixext1
+        case 0xd4:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT1))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 1);
+            return MPACK_TAG_SIZE_FIXEXT1;
+
+        // fixext2
+        case 0xd5:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT2))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 2);
+            return MPACK_TAG_SIZE_FIXEXT2;
+
+        // fixext4
+        case 0xd6:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT4))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 4);
+            return 2;
+
+        // fixext8
+        case 0xd7:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT8))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 8);
+            return MPACK_TAG_SIZE_FIXEXT8;
+
+        // fixext16
+        case 0xd8:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT16))
+                return 0;
+            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 16);
+            return MPACK_TAG_SIZE_FIXEXT16;
+        #endif
+
+        // str8
+        case 0xd9:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR8))
+                return 0;
+            *tag = mpack_tag_make_str(mpack_load_u8(reader->data + 1));
+            return MPACK_TAG_SIZE_STR8;
+
+        // str16
+        case 0xda:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR16))
+                return 0;
+            *tag = mpack_tag_make_str(mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_STR16;
+
+        // str32
+        case 0xdb:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR32))
+                return 0;
+            *tag = mpack_tag_make_str(mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_STR32;
+
+        // array16
+        case 0xdc:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY16))
+                return 0;
+            *tag = mpack_tag_make_array(mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_ARRAY16;
+
+        // array32
+        case 0xdd:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY32))
+                return 0;
+            *tag = mpack_tag_make_array(mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_ARRAY32;
+
+        // map16
+        case 0xde:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP16))
+                return 0;
+            *tag = mpack_tag_make_map(mpack_load_u16(reader->data + 1));
+            return MPACK_TAG_SIZE_MAP16;
+
+        // map32
+        case 0xdf:
+            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP32))
+                return 0;
+            *tag = mpack_tag_make_map(mpack_load_u32(reader->data + 1));
+            return MPACK_TAG_SIZE_MAP32;
+
+        // reserved
+        case 0xc1:
+            mpack_reader_flag_error(reader, mpack_error_invalid);
+            return 0;
+
+        #if !MPACK_EXTENSIONS
+        // ext
+        case 0xc7: // fallthrough
+        case 0xc8: // fallthrough
+        case 0xc9: // fallthrough
+        // fixext
+        case 0xd4: // fallthrough
+        case 0xd5: // fallthrough
+        case 0xd6: // fallthrough
+        case 0xd7: // fallthrough
+        case 0xd8:
+            mpack_reader_flag_error(reader, mpack_error_unsupported);
+            return 0;
+        #endif
+
+        #if MPACK_OPTIMIZE_FOR_SIZE
+        // any other bytes should have been handled by the infix switch
+        default:
+            break;
+        #endif
+    }
+
+    mpack_assert(0, "unreachable");
+    return 0;
+}
+
+mpack_tag_t mpack_read_tag(mpack_reader_t* reader) {
+    mpack_log("reading tag\n");
+
+    // make sure we can read a tag
+    if (mpack_reader_error(reader) != mpack_ok)
+        return mpack_tag_nil();
+    if (mpack_reader_track_element(reader) != mpack_ok)
+        return mpack_tag_nil();
+
+    mpack_tag_t tag = MPACK_TAG_ZERO;
+    size_t count = mpack_parse_tag(reader, &tag);
+    if (count == 0)
+        return mpack_tag_nil();
+
+    #if MPACK_READ_TRACKING
+    mpack_error_t track_error = mpack_ok;
+
+    switch (tag.type) {
+        case mpack_type_map:
+        case mpack_type_array:
+            track_error = mpack_track_push(&reader->track, tag.type, tag.v.n);
+            break;
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+        #endif
+        case mpack_type_str:
+        case mpack_type_bin:
+            track_error = mpack_track_push(&reader->track, tag.type, tag.v.l);
+            break;
+        default:
+            break;
+    }
+
+    if (track_error != mpack_ok) {
+        mpack_reader_flag_error(reader, track_error);
+        return mpack_tag_nil();
+    }
+    #endif
+
+    reader->data += count;
+    return tag;
+}
+
+mpack_tag_t mpack_peek_tag(mpack_reader_t* reader) {
+    mpack_log("peeking tag\n");
+
+    // make sure we can peek a tag
+    if (mpack_reader_error(reader) != mpack_ok)
+        return mpack_tag_nil();
+    if (mpack_reader_track_peek_element(reader) != mpack_ok)
+        return mpack_tag_nil();
+
+    mpack_tag_t tag = MPACK_TAG_ZERO;
+    if (mpack_parse_tag(reader, &tag) == 0)
+        return mpack_tag_nil();
+    return tag;
+}
+
+void mpack_discard(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (mpack_reader_error(reader))
+        return;
+    switch (var.type) {
+        case mpack_type_str:
+            mpack_skip_bytes(reader, var.v.l);
+            mpack_done_str(reader);
+            break;
+        case mpack_type_bin:
+            mpack_skip_bytes(reader, var.v.l);
+            mpack_done_bin(reader);
+            break;
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            mpack_skip_bytes(reader, var.v.l);
+            mpack_done_ext(reader);
+            break;
+        #endif
+        case mpack_type_array: {
+            for (; var.v.n > 0; --var.v.n) {
+                mpack_discard(reader);
+                if (mpack_reader_error(reader))
+                    break;
+            }
+            mpack_done_array(reader);
+            break;
+        }
+        case mpack_type_map: {
+            for (; var.v.n > 0; --var.v.n) {
+                mpack_discard(reader);
+                mpack_discard(reader);
+                if (mpack_reader_error(reader))
+                    break;
+            }
+            mpack_done_map(reader);
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+#if MPACK_EXTENSIONS
+mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size) {
+    mpack_timestamp_t timestamp = {0, 0};
+
+    if (size != 4 && size != 8 && size != 12) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        return timestamp;
+    }
+
+    char buf[12];
+    mpack_read_bytes(reader, buf, size);
+    mpack_done_ext(reader);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return timestamp;
+
+    switch (size) {
+        case 4:
+            timestamp.seconds = (int64_t)(uint64_t)mpack_load_u32(buf);
+            break;
+
+        case 8: {
+            uint64_t packed = mpack_load_u64(buf);
+            timestamp.seconds = (int64_t)(packed & ((UINT64_C(1) << 34) - 1));
+            timestamp.nanoseconds = (uint32_t)(packed >> 34);
+            break;
+        }
+
+        case 12:
+            timestamp.nanoseconds = mpack_load_u32(buf);
+            timestamp.seconds = mpack_load_i64(buf + 4);
+            break;
+
+        default:
+            mpack_assert(false, "unreachable");
+            break;
+    }
+
+    if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        mpack_timestamp_t zero = {0, 0};
+        return zero;
+    }
+
+    return timestamp;
+}
+#endif
+
+#if MPACK_READ_TRACKING
+void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) {
+    if (mpack_reader_error(reader) == mpack_ok)
+        mpack_reader_flag_if_error(reader, mpack_track_pop(&reader->track, type));
+}
+#endif
+
+#if MPACK_DEBUG && MPACK_STDIO
+static size_t mpack_print_read_prefix(mpack_reader_t* reader, size_t length, char* buffer, size_t buffer_size) {
+    if (length == 0)
+        return 0;
+
+    size_t read = (length < buffer_size) ? length : buffer_size;
+    mpack_read_bytes(reader, buffer, read);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return 0;
+
+    mpack_skip_bytes(reader, length - read);
+    return read;
+}
+
+static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, size_t depth) {
+    mpack_tag_t val = mpack_read_tag(reader);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return;
+
+    // We read some bytes from bin and ext so we can print its prefix in hex.
+    char buffer[MPACK_PRINT_BYTE_COUNT];
+    size_t count = 0;
+
+    switch (val.type) {
+        case mpack_type_str:
+            mpack_print_append_cstr(print, "\"");
+            for (size_t i = 0; i < val.v.l; ++i) {
+                char c;
+                mpack_read_bytes(reader, &c, 1);
+                if (mpack_reader_error(reader) != mpack_ok)
+                    return;
+                switch (c) {
+                    case '\n': mpack_print_append_cstr(print, "\\n"); break;
+                    case '\\': mpack_print_append_cstr(print, "\\\\"); break;
+                    case '"': mpack_print_append_cstr(print, "\\\""); break;
+                    default: mpack_print_append(print, &c, 1); break;
+                }
+            }
+            mpack_print_append_cstr(print, "\"");
+            mpack_done_str(reader);
+            return;
+
+        case mpack_type_array:
+            mpack_print_append_cstr(print, "[\n");
+            for (size_t i = 0; i < val.v.n; ++i) {
+                for (size_t j = 0; j < depth + 1; ++j)
+                    mpack_print_append_cstr(print, "    ");
+                mpack_print_element(reader, print, depth + 1);
+                if (mpack_reader_error(reader) != mpack_ok)
+                    return;
+                if (i != val.v.n - 1)
+                    mpack_print_append_cstr(print, ",");
+                mpack_print_append_cstr(print, "\n");
+            }
+            for (size_t i = 0; i < depth; ++i)
+                mpack_print_append_cstr(print, "    ");
+            mpack_print_append_cstr(print, "]");
+            mpack_done_array(reader);
+            return;
+
+        case mpack_type_map:
+            mpack_print_append_cstr(print, "{\n");
+            for (size_t i = 0; i < val.v.n; ++i) {
+                for (size_t j = 0; j < depth + 1; ++j)
+                    mpack_print_append_cstr(print, "    ");
+                mpack_print_element(reader, print, depth + 1);
+                if (mpack_reader_error(reader) != mpack_ok)
+                    return;
+                mpack_print_append_cstr(print, ": ");
+                mpack_print_element(reader, print, depth + 1);
+                if (mpack_reader_error(reader) != mpack_ok)
+                    return;
+                if (i != val.v.n - 1)
+                    mpack_print_append_cstr(print, ",");
+                mpack_print_append_cstr(print, "\n");
+            }
+            for (size_t i = 0; i < depth; ++i)
+                mpack_print_append_cstr(print, "    ");
+            mpack_print_append_cstr(print, "}");
+            mpack_done_map(reader);
+            return;
+
+        // The above cases return so as not to print a pseudo-json value. The
+        // below cases break and print pseudo-json.
+
+        case mpack_type_bin:
+            count = mpack_print_read_prefix(reader, mpack_tag_bin_length(&val), buffer, sizeof(buffer));
+            mpack_done_bin(reader);
+            break;
+
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            count = mpack_print_read_prefix(reader, mpack_tag_ext_length(&val), buffer, sizeof(buffer));
+            mpack_done_ext(reader);
+            break;
+        #endif
+
+        default:
+            break;
+    }
+
+    char buf[256];
+    mpack_tag_debug_pseudo_json(val, buf, sizeof(buf), buffer, count);
+    mpack_print_append_cstr(print, buf);
+}
+
+static void mpack_print_and_destroy(mpack_reader_t* reader, mpack_print_t* print, size_t depth) {
+    for (size_t i = 0; i < depth; ++i)
+        mpack_print_append_cstr(print, "    ");
+    mpack_print_element(reader, print, depth);
+
+    size_t remaining = mpack_reader_remaining(reader, NULL);
+
+    char buf[256];
+    if (mpack_reader_destroy(reader) != mpack_ok) {
+        mpack_snprintf(buf, sizeof(buf), "\n<mpack parsing error %s>", mpack_error_to_string(mpack_reader_error(reader)));
+        buf[sizeof(buf) - 1] = '\0';
+        mpack_print_append_cstr(print, buf);
+    } else if (remaining > 0) {
+        mpack_snprintf(buf, sizeof(buf), "\n<%i extra bytes at end of message>", (int)remaining);
+        buf[sizeof(buf) - 1] = '\0';
+        mpack_print_append_cstr(print, buf);
+    }
+}
+
+static void mpack_print_data(const char* data, size_t len, mpack_print_t* print, size_t depth) {
+    mpack_reader_t reader;
+    mpack_reader_init_data(&reader, data, len);
+    mpack_print_and_destroy(&reader, print, depth);
+}
+
+void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size) {
+    if (buffer_size == 0) {
+        mpack_assert(false, "buffer size is zero!");
+        return;
+    }
+
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = buffer_size;
+    mpack_print_data(data, data_size, &print, 0);
+    mpack_print_append(&print, "",  1); // null-terminator
+    mpack_print_flush(&print);
+
+    // we always make sure there's a null-terminator at the end of the buffer
+    // in case we ran out of space.
+    print.buffer[print.size - 1] = '\0';
+}
+
+void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context) {
+    char buffer[1024];
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = sizeof(buffer);
+    print.callback = callback;
+    print.context = context;
+    mpack_print_data(data, size, &print, 0);
+    mpack_print_flush(&print);
+}
+
+void mpack_print_data_to_file(const char* data, size_t len, FILE* file) {
+    mpack_assert(data != NULL, "data is NULL");
+    mpack_assert(file != NULL, "file is NULL");
+
+    char buffer[1024];
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = sizeof(buffer);
+    print.callback = &mpack_print_file_callback;
+    print.context = file;
+
+    mpack_print_data(data, len, &print, 2);
+    mpack_print_append_cstr(&print, "\n");
+    mpack_print_flush(&print);
+}
+
+void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context) {
+    char buffer[1024];
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = sizeof(buffer);
+    print.callback = callback;
+    print.context = context;
+
+    mpack_reader_t reader;
+    mpack_reader_init_stdfile(&reader, file, false);
+    mpack_print_and_destroy(&reader, &print, 0);
+    mpack_print_flush(&print);
+}
+#endif
+
+#endif
+
+/* mpack/mpack-expect.c.c */
+
+#define MPACK_INTERNAL 1
+
+/* #include "mpack-expect.h" */
+
+#if MPACK_EXPECT
+
+
+// Helpers
+
+MPACK_STATIC_INLINE uint8_t mpack_expect_native_u8(mpack_reader_t* reader) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return 0;
+    uint8_t type;
+    if (!mpack_reader_ensure(reader, sizeof(type)))
+        return 0;
+    type = mpack_load_u8(reader->data);
+    reader->data += sizeof(type);
+    return type;
+}
+
+#if !MPACK_OPTIMIZE_FOR_SIZE
+MPACK_STATIC_INLINE uint16_t mpack_expect_native_u16(mpack_reader_t* reader) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return 0;
+    uint16_t type;
+    if (!mpack_reader_ensure(reader, sizeof(type)))
+        return 0;
+    type = mpack_load_u16(reader->data);
+    reader->data += sizeof(type);
+    return type;
+}
+
+MPACK_STATIC_INLINE uint32_t mpack_expect_native_u32(mpack_reader_t* reader) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return 0;
+    uint32_t type;
+    if (!mpack_reader_ensure(reader, sizeof(type)))
+        return 0;
+    type = mpack_load_u32(reader->data);
+    reader->data += sizeof(type);
+    return type;
+}
+#endif
+
+MPACK_STATIC_INLINE uint8_t mpack_expect_type_byte(mpack_reader_t* reader) {
+    mpack_reader_track_element(reader);
+    return mpack_expect_native_u8(reader);
+}
+
+
+// Basic Number Functions
+
+uint8_t mpack_expect_u8(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= UINT8_MAX)
+            return (uint8_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= 0 && var.v.i <= UINT8_MAX)
+            return (uint8_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+uint16_t mpack_expect_u16(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= UINT16_MAX)
+            return (uint16_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= 0 && var.v.i <= UINT16_MAX)
+            return (uint16_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+uint32_t mpack_expect_u32(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= UINT32_MAX)
+            return (uint32_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= 0 && var.v.i <= UINT32_MAX)
+            return (uint32_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+uint64_t mpack_expect_u64(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        return var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= 0)
+            return (uint64_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+int8_t mpack_expect_i8(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= INT8_MAX)
+            return (int8_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= INT8_MIN && var.v.i <= INT8_MAX)
+            return (int8_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+int16_t mpack_expect_i16(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= INT16_MAX)
+            return (int16_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= INT16_MIN && var.v.i <= INT16_MAX)
+            return (int16_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+int32_t mpack_expect_i32(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= INT32_MAX)
+            return (int32_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        if (var.v.i >= INT32_MIN && var.v.i <= INT32_MAX)
+            return (int32_t)var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+int64_t mpack_expect_i64(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint) {
+        if (var.v.u <= INT64_MAX)
+            return (int64_t)var.v.u;
+    } else if (var.type == mpack_type_int) {
+        return var.v.i;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+float mpack_expect_float(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint)
+        return (float)var.v.u;
+    else if (var.type == mpack_type_int)
+        return (float)var.v.i;
+    else if (var.type == mpack_type_float)
+        return var.v.f;
+    else if (var.type == mpack_type_double)
+        return (float)var.v.d;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0.0f;
+}
+
+double mpack_expect_double(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_uint)
+        return (double)var.v.u;
+    else if (var.type == mpack_type_int)
+        return (double)var.v.i;
+    else if (var.type == mpack_type_float)
+        return (double)var.v.f;
+    else if (var.type == mpack_type_double)
+        return var.v.d;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0.0;
+}
+
+float mpack_expect_float_strict(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_float)
+        return var.v.f;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0.0f;
+}
+
+double mpack_expect_double_strict(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_float)
+        return (double)var.v.f;
+    else if (var.type == mpack_type_double)
+        return var.v.d;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0.0;
+}
+
+
+// Ranged Number Functions
+//
+// All ranged functions are identical other than the type, so we
+// define their content with a macro. The prototypes are still written
+// out in full to support ctags/IDE tools.
+
+#define MPACK_EXPECT_RANGE_IMPL(name, type_t)                           \
+                                                                        \
+    /* make sure the range is sensible */                               \
+    mpack_assert(min_value <= max_value,                                \
+            "min_value %i must be less than or equal to max_value %i",  \
+            min_value, max_value);                                      \
+                                                                        \
+    /* read the value */                                                \
+    type_t val = mpack_expect_##name(reader);                           \
+    if (mpack_reader_error(reader) != mpack_ok)                         \
+        return min_value;                                               \
+                                                                        \
+    /* make sure it fits */                                             \
+    if (val < min_value || val > max_value) {                           \
+        mpack_reader_flag_error(reader, mpack_error_type);              \
+        return min_value;                                               \
+    }                                                                   \
+                                                                        \
+    return val;
+
+uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value) {MPACK_EXPECT_RANGE_IMPL(u8, uint8_t)}
+uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value) {MPACK_EXPECT_RANGE_IMPL(u16, uint16_t)}
+uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(u32, uint32_t)}
+uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value) {MPACK_EXPECT_RANGE_IMPL(u64, uint64_t)}
+
+int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value) {MPACK_EXPECT_RANGE_IMPL(i8, int8_t)}
+int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value) {MPACK_EXPECT_RANGE_IMPL(i16, int16_t)}
+int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value) {MPACK_EXPECT_RANGE_IMPL(i32, int32_t)}
+int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value) {MPACK_EXPECT_RANGE_IMPL(i64, int64_t)}
+
+float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value) {MPACK_EXPECT_RANGE_IMPL(float, float)}
+double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value) {MPACK_EXPECT_RANGE_IMPL(double, double)}
+
+uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(map, uint32_t)}
+uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(array, uint32_t)}
+
+
+// Matching Number Functions
+
+void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value) {
+    if (mpack_expect_u64(reader) != value)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+void mpack_expect_int_match(mpack_reader_t* reader, int64_t value) {
+    if (mpack_expect_i64(reader) != value)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+
+// Other Basic Types
+
+void mpack_expect_nil(mpack_reader_t* reader) {
+    if (mpack_expect_type_byte(reader) != 0xc0)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+bool mpack_expect_bool(mpack_reader_t* reader) {
+    uint8_t type = mpack_expect_type_byte(reader);
+    if ((type & ~1) != 0xc2)
+        mpack_reader_flag_error(reader, mpack_error_type);
+    return (bool)(type & 1);
+}
+
+void mpack_expect_true(mpack_reader_t* reader) {
+    if (mpack_expect_bool(reader) != true)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+void mpack_expect_false(mpack_reader_t* reader) {
+    if (mpack_expect_bool(reader) != false)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+#if MPACK_EXTENSIONS
+mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader) {
+    mpack_timestamp_t zero = {0, 0};
+
+    mpack_tag_t tag = mpack_read_tag(reader);
+    if (tag.type != mpack_type_ext) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return zero;
+    }
+    if (mpack_tag_ext_exttype(&tag) != MPACK_EXTTYPE_TIMESTAMP) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return zero;
+    }
+
+    return mpack_read_timestamp(reader, mpack_tag_ext_length(&tag));
+}
+
+int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader) {
+    return mpack_expect_timestamp(reader).seconds;
+}
+#endif
+
+
+// Compound Types
+
+uint32_t mpack_expect_map(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_map)
+        return var.v.n;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count) {
+    if (mpack_expect_map(reader) != count)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count) {
+    mpack_assert(count != NULL, "count cannot be NULL");
+
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_nil) {
+        *count = 0;
+        return false;
+    }
+    if (var.type == mpack_type_map) {
+        *count = var.v.n;
+        return true;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    *count = 0;
+    return false;
+}
+
+bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) {
+    mpack_assert(count != NULL, "count cannot be NULL");
+
+    bool has_map = mpack_expect_map_or_nil(reader, count);
+    if (has_map && *count > max_count) {
+        *count = 0;
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return false;
+    }
+    return has_map;
+}
+
+uint32_t mpack_expect_array(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_array)
+        return var.v.n;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count) {
+    if (mpack_expect_array(reader) != count)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count) {
+    mpack_assert(count != NULL, "count cannot be NULL");
+
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_nil) {
+        *count = 0;
+        return false;
+    }
+    if (var.type == mpack_type_array) {
+        *count = var.v.n;
+        return true;
+    }
+    mpack_reader_flag_error(reader, mpack_error_type);
+    *count = 0;
+    return false;
+}
+
+bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) {
+    mpack_assert(count != NULL, "count cannot be NULL");
+
+    bool has_array = mpack_expect_array_or_nil(reader, count);
+    if (has_array && *count > max_count) {
+        *count = 0;
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return false;
+    }
+    return has_array;
+}
+
+#ifdef MPACK_MALLOC
+void* mpack_expect_array_alloc_impl(mpack_reader_t* reader, size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil) {
+    mpack_assert(out_count != NULL, "out_count cannot be NULL");
+    *out_count = 0;
+
+    uint32_t count;
+    bool has_array = true;
+    if (allow_nil)
+        has_array = mpack_expect_array_max_or_nil(reader, max_count, &count);
+    else
+        count = mpack_expect_array_max(reader, max_count);
+    if (mpack_reader_error(reader))
+        return NULL;
+
+    // size 0 is not an error; we return NULL for no elements.
+    if (count == 0) {
+        // we call mpack_done_array() automatically ONLY if we are using
+        // the _or_nil variant. this is the only way to allow nil and empty
+        // to work the same way.
+        if (allow_nil && has_array)
+            mpack_done_array(reader);
+        return NULL;
+    }
+
+    void* p = MPACK_MALLOC(element_size * count);
+    if (p == NULL) {
+        mpack_reader_flag_error(reader, mpack_error_memory);
+        return NULL;
+    }
+
+    *out_count = count;
+    return p;
+}
+#endif
+
+
+// Str, Bin and Ext Functions
+
+uint32_t mpack_expect_str(mpack_reader_t* reader) {
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_str)
+        return var.v.l;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+    #else
+    uint8_t type = mpack_expect_type_byte(reader);
+    uint32_t count;
+
+    if ((type >> 5) == 5) {
+        count = type & (uint8_t)~0xe0;
+    } else if (type == 0xd9) {
+        count = mpack_expect_native_u8(reader);
+    } else if (type == 0xda) {
+        count = mpack_expect_native_u16(reader);
+    } else if (type == 0xdb) {
+        count = mpack_expect_native_u32(reader);
+    } else {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return 0;
+    }
+
+    #if MPACK_READ_TRACKING
+    mpack_reader_flag_if_error(reader, mpack_track_push(&reader->track, mpack_type_str, count));
+    #endif
+    return count;
+    #endif
+}
+
+size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize) {
+    mpack_assert(buf != NULL, "buf cannot be NULL");
+
+    size_t length = mpack_expect_str(reader);
+    if (mpack_reader_error(reader))
+        return 0;
+
+    if (length > bufsize) {
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        return 0;
+    }
+
+    mpack_read_bytes(reader, buf, length);
+    if (mpack_reader_error(reader))
+        return 0;
+
+    mpack_done_str(reader);
+    return length;
+}
+
+size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t size) {
+    mpack_assert(buf != NULL, "buf cannot be NULL");
+
+    size_t length = mpack_expect_str_buf(reader, buf, size);
+
+    if (!mpack_utf8_check(buf, length)) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return 0;
+    }
+
+    return length;
+}
+
+uint32_t mpack_expect_bin(mpack_reader_t* reader) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_bin)
+        return var.v.l;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t bufsize) {
+    mpack_assert(buf != NULL, "buf cannot be NULL");
+
+    size_t binsize = mpack_expect_bin(reader);
+    if (mpack_reader_error(reader))
+        return 0;
+    if (binsize > bufsize) {
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        return 0;
+    }
+    mpack_read_bytes(reader, buf, binsize);
+    if (mpack_reader_error(reader))
+        return 0;
+    mpack_done_bin(reader);
+    return binsize;
+}
+
+void mpack_expect_bin_size_buf(mpack_reader_t* reader, char* buf, uint32_t size) {
+    mpack_assert(buf != NULL, "buf cannot be NULL");
+    mpack_expect_bin_size(reader, size);
+    mpack_read_bytes(reader, buf, size);
+    mpack_done_bin(reader);
+}
+
+#if MPACK_EXTENSIONS
+uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type) {
+    mpack_tag_t var = mpack_read_tag(reader);
+    if (var.type == mpack_type_ext) {
+        *type = mpack_tag_ext_exttype(&var);
+        return mpack_tag_ext_length(&var);
+    }
+    *type = 0;
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return 0;
+}
+
+size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t bufsize) {
+    mpack_assert(buf != NULL, "buf cannot be NULL");
+
+    size_t extsize = mpack_expect_ext(reader, type);
+    if (mpack_reader_error(reader))
+        return 0;
+    if (extsize > bufsize) {
+        *type = 0;
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        return 0;
+    }
+    mpack_read_bytes(reader, buf, extsize);
+    if (mpack_reader_error(reader)) {
+        *type = 0;
+        return 0;
+    }
+    mpack_done_ext(reader);
+    return extsize;
+}
+#endif
+
+void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) {
+    uint32_t length = mpack_expect_str(reader);
+    mpack_read_cstr(reader, buf, bufsize, length);
+    mpack_done_str(reader);
+}
+
+void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) {
+    uint32_t length = mpack_expect_str(reader);
+    mpack_read_utf8_cstr(reader, buf, bufsize, length);
+    mpack_done_str(reader);
+}
+
+#ifdef MPACK_MALLOC
+static char* mpack_expect_cstr_alloc_unchecked(mpack_reader_t* reader, size_t maxsize, size_t* out_length) {
+    mpack_assert(out_length != NULL, "out_length cannot be NULL");
+    *out_length = 0;
+
+    // make sure argument makes sense
+    if (maxsize < 1) {
+        mpack_break("maxsize is zero; you must have room for at least a null-terminator");
+        mpack_reader_flag_error(reader, mpack_error_bug);
+        return NULL;
+    }
+
+    if (maxsize > UINT32_MAX)
+        maxsize = UINT32_MAX;
+
+    size_t length = mpack_expect_str_max(reader, (uint32_t)maxsize - 1);
+    char* str = mpack_read_bytes_alloc_impl(reader, length, true);
+    mpack_done_str(reader);
+
+    if (str)
+        *out_length = length;
+    return str;
+}
+
+char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize) {
+    size_t length;
+    char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length);
+
+    if (str && !mpack_str_check_no_null(str, length)) {
+        MPACK_FREE(str);
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return NULL;
+    }
+
+    return str;
+}
+
+char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize) {
+    size_t length;
+    char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length);
+
+    if (str && !mpack_utf8_check_no_null(str, length)) {
+        MPACK_FREE(str);
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return NULL;
+    }
+
+    return str;
+}
+#endif
+
+void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t len) {
+    mpack_assert(str != NULL, "str cannot be NULL");
+
+    // expect a str the correct length
+    if (len > UINT32_MAX)
+        mpack_reader_flag_error(reader, mpack_error_type);
+    mpack_expect_str_length(reader, (uint32_t)len);
+    if (mpack_reader_error(reader))
+        return;
+    mpack_reader_track_bytes(reader, (uint32_t)len);
+
+    // check each byte one by one (matched strings are likely to be very small)
+    for (; len > 0; --len) {
+        if (mpack_expect_native_u8(reader) != *str++) {
+            mpack_reader_flag_error(reader, mpack_error_type);
+            return;
+        }
+    }
+
+    mpack_done_str(reader);
+}
+
+void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t expected) {
+    mpack_tag_t actual = mpack_read_tag(reader);
+    if (!mpack_tag_equal(actual, expected))
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+#ifdef MPACK_MALLOC
+char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size) {
+    mpack_assert(size != NULL, "size cannot be NULL");
+    *size = 0;
+
+    if (maxsize > UINT32_MAX)
+        maxsize = UINT32_MAX;
+
+    size_t length = mpack_expect_bin_max(reader, (uint32_t)maxsize);
+    if (mpack_reader_error(reader))
+        return NULL;
+
+    char* data = mpack_read_bytes_alloc(reader, length);
+    mpack_done_bin(reader);
+
+    if (data)
+        *size = length;
+    return data;
+}
+#endif
+
+#if MPACK_EXTENSIONS && defined(MPACK_MALLOC)
+char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size) {
+    mpack_assert(size != NULL, "size cannot be NULL");
+    *size = 0;
+
+    if (maxsize > UINT32_MAX)
+        maxsize = UINT32_MAX;
+
+    size_t length = mpack_expect_ext_max(reader, type, (uint32_t)maxsize);
+    if (mpack_reader_error(reader))
+        return NULL;
+
+    char* data = mpack_read_bytes_alloc(reader, length);
+    mpack_done_ext(reader);
+
+    if (data) {
+        *size = length;
+    } else {
+        *type = 0;
+    }
+    return data;
+}
+#endif
+
+size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count) {
+
+    // read the string in-place
+    size_t keylen = mpack_expect_str(reader);
+    const char* key = mpack_read_bytes_inplace(reader, keylen);
+    mpack_done_str(reader);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return count;
+
+    // find what key it matches
+    for (size_t i = 0; i < count; ++i) {
+        const char* other = strings[i];
+        size_t otherlen = mpack_strlen(other);
+        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
+            return i;
+    }
+
+    // no matches
+    mpack_reader_flag_error(reader, mpack_error_type);
+    return count;
+}
+
+size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return count;
+
+    mpack_assert(count != 0, "count cannot be zero; no strings are valid!");
+    mpack_assert(strings != NULL, "strings cannot be NULL");
+
+    // the key is only recognized if it is a string
+    if (mpack_peek_tag(reader).type != mpack_type_str) {
+        mpack_discard(reader);
+        return count;
+    }
+
+    // read the string in-place
+    size_t keylen = mpack_expect_str(reader);
+    const char* key = mpack_read_bytes_inplace(reader, keylen);
+    mpack_done_str(reader);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return count;
+
+    // find what key it matches
+    for (size_t i = 0; i < count; ++i) {
+        const char* other = strings[i];
+        size_t otherlen = mpack_strlen(other);
+        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
+            return i;
+    }
+
+    // no matches
+    return count;
+}
+
+size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count) {
+    if (mpack_reader_error(reader) != mpack_ok)
+        return count;
+
+    if (count == 0) {
+        mpack_break("count cannot be zero; no keys are valid!");
+        mpack_reader_flag_error(reader, mpack_error_bug);
+        return count;
+    }
+    mpack_assert(found != NULL, "found cannot be NULL");
+
+    // the key is only recognized if it is an unsigned int
+    if (mpack_peek_tag(reader).type != mpack_type_uint) {
+        mpack_discard(reader);
+        return count;
+    }
+
+    // read the key
+    uint64_t value = mpack_expect_u64(reader);
+    if (mpack_reader_error(reader) != mpack_ok)
+        return count;
+
+    // unrecognized keys are fine, we just return count
+    if (value >= count)
+        return count;
+
+    // check if this key is a duplicate
+    if (found[value]) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        return count;
+    }
+
+    found[value] = true;
+    return (size_t)value;
+}
+
+size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[], bool found[], size_t count) {
+    size_t i = mpack_expect_enum_optional(reader, keys, count);
+
+    // unrecognized keys are fine, we just return count
+    if (i == count)
+        return count;
+
+    // check if this key is a duplicate
+    mpack_assert(found != NULL, "found cannot be NULL");
+    if (found[i]) {
+        mpack_reader_flag_error(reader, mpack_error_invalid);
+        return count;
+    }
+
+    found[i] = true;
+    return i;
+}
+
+#endif
+
+
+/* mpack/mpack-node.c.c */
+
+#define MPACK_INTERNAL 1
+
+/* #include "mpack-node.h" */
+
+#if MPACK_NODE
+
+MPACK_STATIC_INLINE const char* mpack_node_data_unchecked(mpack_node_t node) {
+    mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!");
+
+    mpack_type_t type = node.data->type;
+    MPACK_UNUSED(type);
+    #if MPACK_EXTENSIONS
+    mpack_assert(type == mpack_type_str || type == mpack_type_bin || type == mpack_type_ext,
+            "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type));
+    #else
+    mpack_assert(type == mpack_type_str || type == mpack_type_bin,
+            "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type));
+    #endif
+
+    return node.tree->data + node.data->value.offset;
+}
+
+#if MPACK_EXTENSIONS
+MPACK_STATIC_INLINE int8_t mpack_node_exttype_unchecked(mpack_node_t node) {
+    mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!");
+
+    mpack_type_t type = node.data->type;
+    MPACK_UNUSED(type);
+    mpack_assert(type == mpack_type_ext, "node of type %i (%s) is not an ext type!",
+            type, mpack_type_to_string(type));
+
+    // the exttype of an ext node is stored in the byte preceding the data
+    return mpack_load_i8(mpack_node_data_unchecked(node) - 1);
+}
+#endif
+
+
+
+/*
+ * Tree Parsing
+ */
+
+#ifdef MPACK_MALLOC
+
+// fix up the alloc size to make sure it exactly fits the
+// maximum number of nodes it can contain (the allocator will
+// waste it back anyway, but we round it down just in case)
+
+#define MPACK_NODES_PER_PAGE \
+    ((MPACK_NODE_PAGE_SIZE - sizeof(mpack_tree_page_t)) / sizeof(mpack_node_data_t) + 1)
+
+#define MPACK_PAGE_ALLOC_SIZE \
+    (sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (MPACK_NODES_PER_PAGE - 1))
+
+#endif
+
+#ifdef MPACK_MALLOC
+/*
+ * Fills the tree until we have at least enough bytes for the current node.
+ */
+static bool mpack_tree_reserve_fill(mpack_tree_t* tree) {
+    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
+
+    size_t bytes = tree->parser.current_node_reserved;
+    mpack_assert(bytes > tree->parser.possible_nodes_left,
+            "there are already enough bytes! call mpack_tree_ensure() instead.");
+    mpack_log("filling to reserve %i bytes\n", (int)bytes);
+
+    // if the necessary bytes would put us over the maximum tree
+    // size, fail right away.
+    // TODO: check for overflow?
+    if (tree->data_length + bytes > tree->max_size) {
+        mpack_tree_flag_error(tree, mpack_error_too_big);
+        return false;
+    }
+
+    // we'll need a read function to fetch more data. if there's
+    // no read function, the data should contain an entire message
+    // (or messages), so we flag it as invalid.
+    if (tree->read_fn == NULL) {
+        mpack_log("tree has no read function!\n");
+        mpack_tree_flag_error(tree, mpack_error_invalid);
+        return false;
+    }
+
+    // expand the buffer if needed
+    if (tree->data_length + bytes > tree->buffer_capacity) {
+
+        // TODO: check for overflow?
+        size_t new_capacity = (tree->buffer_capacity == 0) ? MPACK_BUFFER_SIZE : tree->buffer_capacity;
+        while (new_capacity < tree->data_length + bytes)
+            new_capacity *= 2;
+        if (new_capacity > tree->max_size)
+            new_capacity = tree->max_size;
+
+        mpack_log("expanding buffer from %i to %i\n", (int)tree->buffer_capacity, (int)new_capacity);
+
+        char* new_buffer;
+        if (tree->buffer == NULL)
+            new_buffer = (char*)MPACK_MALLOC(new_capacity);
+        else
+            new_buffer = (char*)mpack_realloc(tree->buffer, tree->data_length, new_capacity);
+
+        if (new_buffer == NULL) {
+            mpack_tree_flag_error(tree, mpack_error_memory);
+            return false;
+        }
+
+        tree->data = new_buffer;
+        tree->buffer = new_buffer;
+        tree->buffer_capacity = new_capacity;
+    }
+
+    // request as much data as possible, looping until we have
+    // all the data we need
+    do {
+        size_t read = tree->read_fn(tree, tree->buffer + tree->data_length, tree->buffer_capacity - tree->data_length);
+
+        // If the fill function encounters an error, it should flag an error on
+        // the tree.
+        if (mpack_tree_error(tree) != mpack_ok)
+            return false;
+
+        // We guard against fill functions that return -1 just in case.
+        if (read == (size_t)(-1)) {
+            mpack_tree_flag_error(tree, mpack_error_io);
+            return false;
+        }
+
+        // If the fill function returns 0, the data is not available yet. We
+        // return false to stop parsing the current node.
+        if (read == 0) {
+            mpack_log("not enough data.\n");
+            return false;
+        }
+
+        mpack_log("read %u more bytes\n", (uint32_t)read);
+        tree->data_length += read;
+        tree->parser.possible_nodes_left += read;
+    } while (tree->parser.possible_nodes_left < bytes);
+
+    return true;
+}
+#endif
+
+/*
+ * Ensures there are enough additional bytes in the tree for the current node
+ * (including reserved bytes for the children of this node, and in addition to
+ * the reserved bytes for children of previous compound nodes), reading more
+ * data if needed.
+ *
+ * extra_bytes is the number of additional bytes to reserve for the current
+ * node beyond the type byte (since one byte is already reserved for each node
+ * by its parent array or map.)
+ *
+ * This may reallocate the tree, which means the tree->data pointer may change!
+ *
+ * Returns false if not enough bytes could be read.
+ */
+MPACK_STATIC_INLINE bool mpack_tree_reserve_bytes(mpack_tree_t* tree, size_t extra_bytes) {
+    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
+
+    // We guard against overflow here. A compound type could declare more than
+    // UINT32_MAX contents which overflows SIZE_MAX on 32-bit platforms. We
+    // flag mpack_error_invalid instead of mpack_error_too_big since it's far
+    // more likely that the message is corrupt than that the data is valid but
+    // not parseable on this architecture (see test_read_node_possible() in
+    // test-node.c .)
+    if ((uint64_t)tree->parser.current_node_reserved + (uint64_t)extra_bytes > SIZE_MAX) {
+        mpack_tree_flag_error(tree, mpack_error_invalid);
+        return false;
+    }
+
+    tree->parser.current_node_reserved += extra_bytes;
+
+    // Note that possible_nodes_left already accounts for reserved bytes for
+    // children of previous compound nodes. So even if there are hundreds of
+    // bytes left in the buffer, we might need to read anyway.
+    if (tree->parser.current_node_reserved <= tree->parser.possible_nodes_left)
+        return true;
+
+    #ifdef MPACK_MALLOC
+    return mpack_tree_reserve_fill(tree);
+    #else
+    return false;
+    #endif
+}
+
+MPACK_STATIC_INLINE size_t mpack_tree_parser_stack_capacity(mpack_tree_t* tree) {
+    #ifdef MPACK_MALLOC
+    return tree->parser.stack_capacity;
+    #else
+    return sizeof(tree->parser.stack) / sizeof(tree->parser.stack[0]);
+    #endif
+}
+
+static bool mpack_tree_push_stack(mpack_tree_t* tree, mpack_node_data_t* first_child, size_t total) {
+    mpack_tree_parser_t* parser = &tree->parser;
+    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
+
+    // No need to push empty containers
+    if (total == 0)
+        return true;
+
+    // Make sure we have enough room in the stack
+    if (parser->level + 1 == mpack_tree_parser_stack_capacity(tree)) {
+        #ifdef MPACK_MALLOC
+        size_t new_capacity = parser->stack_capacity * 2;
+        mpack_log("growing parse stack to capacity %i\n", (int)new_capacity);
+
+        // Replace the stack-allocated parsing stack
+        if (!parser->stack_owned) {
+            mpack_level_t* new_stack = (mpack_level_t*)MPACK_MALLOC(sizeof(mpack_level_t) * new_capacity);
+            if (!new_stack) {
+                mpack_tree_flag_error(tree, mpack_error_memory);
+                return false;
+            }
+            mpack_memcpy(new_stack, parser->stack, sizeof(mpack_level_t) * parser->stack_capacity);
+            parser->stack = new_stack;
+            parser->stack_owned = true;
+
+        // Realloc the allocated parsing stack
+        } else {
+            mpack_level_t* new_stack = (mpack_level_t*)mpack_realloc(parser->stack,
+                    sizeof(mpack_level_t) * parser->stack_capacity, sizeof(mpack_level_t) * new_capacity);
+            if (!new_stack) {
+                mpack_tree_flag_error(tree, mpack_error_memory);
+                return false;
+            }
+            parser->stack = new_stack;
+        }
+        parser->stack_capacity = new_capacity;
+        #else
+        mpack_tree_flag_error(tree, mpack_error_too_big);
+        return false;
+        #endif
+    }
+
+    // Push the contents of this node onto the parsing stack
+    ++parser->level;
+    parser->stack[parser->level].child = first_child;
+    parser->stack[parser->level].left = total;
+    return true;
+}
+
+static bool mpack_tree_parse_children(mpack_tree_t* tree, mpack_node_data_t* node) {
+    mpack_tree_parser_t* parser = &tree->parser;
+    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
+
+    mpack_type_t type = node->type;
+    size_t total = node->len;
+
+    // Calculate total elements to read
+    if (type == mpack_type_map) {
+        if ((uint64_t)total * 2 > SIZE_MAX) {
+            mpack_tree_flag_error(tree, mpack_error_too_big);
+            return false;
+        }
+        total *= 2;
+    }
+
+    // Make sure we are under our total node limit (TODO can this overflow?)
+    tree->node_count += total;
+    if (tree->node_count > tree->max_nodes) {
+        mpack_tree_flag_error(tree, mpack_error_too_big);
+        return false;
+    }
+
+    // Each node is at least one byte. Count these bytes now to make
+    // sure there is enough data left.
+    if (!mpack_tree_reserve_bytes(tree, total))
+        return false;
+
+    // If there are enough nodes left in the current page, no need to grow
+    if (total <= parser->nodes_left) {
+        node->value.children = parser->nodes;
+        parser->nodes += total;
+        parser->nodes_left -= total;
+
+    } else {
+
+        #ifdef MPACK_MALLOC
+
+        // We can't grow if we're using a fixed pool (i.e. we didn't start with a page)
+        if (!tree->next) {
+            mpack_tree_flag_error(tree, mpack_error_too_big);
+            return false;
+        }
+
+        // Otherwise we need to grow, and the node's children need to be contiguous.
+        // This is a heuristic to decide whether we should waste the remaining space
+        // in the current page and start a new one, or give the children their
+        // own page. With a fraction of 1/8, this causes at most 12% additional
+        // waste. Note that reducing this too much causes less cache coherence and
+        // more malloc() overhead due to smaller allocations, so there's a tradeoff
+        // here. This heuristic could use some improvement, especially with custom
+        // page sizes.
+
+        mpack_tree_page_t* page;
+
+        if (total > MPACK_NODES_PER_PAGE || parser->nodes_left > MPACK_NODES_PER_PAGE / 8) {
+            // TODO: this should check for overflow
+            page = (mpack_tree_page_t*)MPACK_MALLOC(
+                    sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (total - 1));
+            if (page == NULL) {
+                mpack_tree_flag_error(tree, mpack_error_memory);
+                return false;
+            }
+            mpack_log("allocated seperate page %p for %i children, %i left in page of %i total\n",
+                    (void*)page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE);
+
+            node->value.children = page->nodes;
+
+        } else {
+            page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE);
+            if (page == NULL) {
+                mpack_tree_flag_error(tree, mpack_error_memory);
+                return false;
+            }
+            mpack_log("allocated new page %p for %i children, wasting %i in page of %i total\n",
+                    (void*)page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE);
+
+            node->value.children = page->nodes;
+            parser->nodes = page->nodes + total;
+            parser->nodes_left = MPACK_NODES_PER_PAGE - total;
+        }
+
+        page->next = tree->next;
+        tree->next = page;
+
+        #else
+        // We can't grow if we don't have an allocator
+        mpack_tree_flag_error(tree, mpack_error_too_big);
+        return false;
+        #endif
+    }
+
+    return mpack_tree_push_stack(tree, node->value.children, total);
+}
+
+static bool mpack_tree_parse_bytes(mpack_tree_t* tree, mpack_node_data_t* node) {
+    node->value.offset = tree->size + tree->parser.current_node_reserved + 1;
+    return mpack_tree_reserve_bytes(tree, node->len);
+}
+
+#if MPACK_EXTENSIONS
+static bool mpack_tree_parse_ext(mpack_tree_t* tree, mpack_node_data_t* node) {
+    // reserve space for exttype
+    tree->parser.current_node_reserved += sizeof(int8_t);
+    node->type = mpack_type_ext;
+    return mpack_tree_parse_bytes(tree, node);
+}
+#endif
+
+static bool mpack_tree_parse_node_contents(mpack_tree_t* tree, mpack_node_data_t* node) {
+    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
+    mpack_assert(node != NULL, "null node?");
+
+    // read the type. we've already accounted for this byte in
+    // possible_nodes_left, so we already know it is in bounds, and we don't
+    // need to reserve it for this node.
+    mpack_assert(tree->data_length > tree->size);
+    uint8_t type = mpack_load_u8(tree->data + tree->size);
+    mpack_log("node type %x\n", type);
+    tree->parser.current_node_reserved = 0;
+
+    // as with mpack_read_tag(), the fastest way to parse a node is to switch
+    // on the first byte, and to explicitly list every possible byte. we switch
+    // on the first four bits in size-optimized builds.
+
+    #if MPACK_OPTIMIZE_FOR_SIZE
+    switch (type >> 4) {
+
+        // positive fixnum
+        case 0x0: case 0x1: case 0x2: case 0x3:
+        case 0x4: case 0x5: case 0x6: case 0x7:
+            node->type = mpack_type_uint;
+            node->value.u = type;
+            return true;
+
+        // negative fixnum
+        case 0xe: case 0xf:
+            node->type = mpack_type_int;
+            node->value.i = (int8_t)type;
+            return true;
+
+        // fixmap
+        case 0x8:
+            node->type = mpack_type_map;
+            node->len = (uint32_t)(type & ~0xf0);
+            return mpack_tree_parse_children(tree, node);
+
+        // fixarray
+        case 0x9:
+            node->type = mpack_type_array;
+            node->len = (uint32_t)(type & ~0xf0);
+            return mpack_tree_parse_children(tree, node);
+
+        // fixstr
+        case 0xa: case 0xb:
+            node->type = mpack_type_str;
+            node->len = (uint32_t)(type & ~0xe0);
+            return mpack_tree_parse_bytes(tree, node);
+
+        // not one of the common infix types
+        default:
+            break;
+    }
+    #endif
+
+    switch (type) {
+
+        #if !MPACK_OPTIMIZE_FOR_SIZE
+        // positive fixnum
+        case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
+        case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+        case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
+        case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+        case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
+        case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+        case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
+        case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+        case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
+        case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
+        case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57:
+        case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f:
+        case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
+        case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+        case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77:
+        case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+            node->type = mpack_type_uint;
+            node->value.u = type;
+            return true;
+
+        // negative fixnum
+        case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+        case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
+        case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+        case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff:
+            node->type = mpack_type_int;
+            node->value.i = (int8_t)type;
+            return true;
+
+        // fixmap
+        case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
+        case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+            node->type = mpack_type_map;
+            node->len = (uint32_t)(type & ~0xf0);
+            return mpack_tree_parse_children(tree, node);
+
+        // fixarray
+        case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
+        case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+            node->type = mpack_type_array;
+            node->len = (uint32_t)(type & ~0xf0);
+            return mpack_tree_parse_children(tree, node);
+
+        // fixstr
+        case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+        case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf:
+        case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+        case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+            node->type = mpack_type_str;
+            node->len = (uint32_t)(type & ~0xe0);
+            return mpack_tree_parse_bytes(tree, node);
+        #endif
+
+        // nil
+        case 0xc0:
+            node->type = mpack_type_nil;
+            return true;
+
+        // bool
+        case 0xc2: case 0xc3:
+            node->type = mpack_type_bool;
+            node->value.b = type & 1;
+            return true;
+
+        // bin8
+        case 0xc4:
+            node->type = mpack_type_bin;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
+                return false;
+            node->len = mpack_load_u8(tree->data + tree->size + 1);
+            return mpack_tree_parse_bytes(tree, node);
+
+        // bin16
+        case 0xc5:
+            node->type = mpack_type_bin;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->len = mpack_load_u16(tree->data + tree->size + 1);
+            return mpack_tree_parse_bytes(tree, node);
+
+        // bin32
+        case 0xc6:
+            node->type = mpack_type_bin;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->len = mpack_load_u32(tree->data + tree->size + 1);
+            return mpack_tree_parse_bytes(tree, node);
+
+        #if MPACK_EXTENSIONS
+        // ext8
+        case 0xc7:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
+                return false;
+            node->len = mpack_load_u8(tree->data + tree->size + 1);
+            return mpack_tree_parse_ext(tree, node);
+
+        // ext16
+        case 0xc8:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->len = mpack_load_u16(tree->data + tree->size + 1);
+            return mpack_tree_parse_ext(tree, node);
+
+        // ext32
+        case 0xc9:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->len = mpack_load_u32(tree->data + tree->size + 1);
+            return mpack_tree_parse_ext(tree, node);
+        #endif
+
+        // float
+        case 0xca:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(float)))
+                return false;
+            node->value.f = mpack_load_float(tree->data + tree->size + 1);
+            node->type = mpack_type_float;
+            return true;
+
+        // double
+        case 0xcb:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(double)))
+                return false;
+            node->value.d = mpack_load_double(tree->data + tree->size + 1);
+            node->type = mpack_type_double;
+            return true;
+
+        // uint8
+        case 0xcc:
+            node->type = mpack_type_uint;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
+                return false;
+            node->value.u = mpack_load_u8(tree->data + tree->size + 1);
+            return true;
+
+        // uint16
+        case 0xcd:
+            node->type = mpack_type_uint;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->value.u = mpack_load_u16(tree->data + tree->size + 1);
+            return true;
+
+        // uint32
+        case 0xce:
+            node->type = mpack_type_uint;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->value.u = mpack_load_u32(tree->data + tree->size + 1);
+            return true;
+
+        // uint64
+        case 0xcf:
+            node->type = mpack_type_uint;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint64_t)))
+                return false;
+            node->value.u = mpack_load_u64(tree->data + tree->size + 1);
+            return true;
+
+        // int8
+        case 0xd0:
+            node->type = mpack_type_int;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(int8_t)))
+                return false;
+            node->value.i = mpack_load_i8(tree->data + tree->size + 1);
+            return true;
+
+        // int16
+        case 0xd1:
+            node->type = mpack_type_int;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(int16_t)))
+                return false;
+            node->value.i = mpack_load_i16(tree->data + tree->size + 1);
+            return true;
+
+        // int32
+        case 0xd2:
+            node->type = mpack_type_int;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(int32_t)))
+                return false;
+            node->value.i = mpack_load_i32(tree->data + tree->size + 1);
+            return true;
+
+        // int64
+        case 0xd3:
+            node->type = mpack_type_int;
+            if (!mpack_tree_reserve_bytes(tree, sizeof(int64_t)))
+                return false;
+            node->value.i = mpack_load_i64(tree->data + tree->size + 1);
+            return true;
+
+        #if MPACK_EXTENSIONS
+        // fixext1
+        case 0xd4:
+            node->len = 1;
+            return mpack_tree_parse_ext(tree, node);
+
+        // fixext2
+        case 0xd5:
+            node->len = 2;
+            return mpack_tree_parse_ext(tree, node);
+
+        // fixext4
+        case 0xd6:
+            node->len = 4;
+            return mpack_tree_parse_ext(tree, node);
+
+        // fixext8
+        case 0xd7:
+            node->len = 8;
+            return mpack_tree_parse_ext(tree, node);
+
+        // fixext16
+        case 0xd8:
+            node->len = 16;
+            return mpack_tree_parse_ext(tree, node);
+        #endif
+
+        // str8
+        case 0xd9:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
+                return false;
+            node->len = mpack_load_u8(tree->data + tree->size + 1);
+            node->type = mpack_type_str;
+            return mpack_tree_parse_bytes(tree, node);
+
+        // str16
+        case 0xda:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->len = mpack_load_u16(tree->data + tree->size + 1);
+            node->type = mpack_type_str;
+            return mpack_tree_parse_bytes(tree, node);
+
+        // str32
+        case 0xdb:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->len = mpack_load_u32(tree->data + tree->size + 1);
+            node->type = mpack_type_str;
+            return mpack_tree_parse_bytes(tree, node);
+
+        // array16
+        case 0xdc:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->len = mpack_load_u16(tree->data + tree->size + 1);
+            node->type = mpack_type_array;
+            return mpack_tree_parse_children(tree, node);
+
+        // array32
+        case 0xdd:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->len = mpack_load_u32(tree->data + tree->size + 1);
+            node->type = mpack_type_array;
+            return mpack_tree_parse_children(tree, node);
+
+        // map16
+        case 0xde:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
+                return false;
+            node->len = mpack_load_u16(tree->data + tree->size + 1);
+            node->type = mpack_type_map;
+            return mpack_tree_parse_children(tree, node);
+
+        // map32
+        case 0xdf:
+            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
+                return false;
+            node->len = mpack_load_u32(tree->data + tree->size + 1);
+            node->type = mpack_type_map;
+            return mpack_tree_parse_children(tree, node);
+
+        // reserved
+        case 0xc1:
+            mpack_tree_flag_error(tree, mpack_error_invalid);
+            return false;
+
+        #if !MPACK_EXTENSIONS
+        // ext
+        case 0xc7: // fallthrough
+        case 0xc8: // fallthrough
+        case 0xc9: // fallthrough
+        // fixext
+        case 0xd4: // fallthrough
+        case 0xd5: // fallthrough
+        case 0xd6: // fallthrough
+        case 0xd7: // fallthrough
+        case 0xd8:
+            mpack_tree_flag_error(tree, mpack_error_unsupported);
+            return false;
+        #endif
+
+        #if MPACK_OPTIMIZE_FOR_SIZE
+        // any other bytes should have been handled by the infix switch
+        default:
+            break;
+        #endif
+    }
+
+    mpack_assert(0, "unreachable");
+    return false;
+}
+
+static bool mpack_tree_parse_node(mpack_tree_t* tree, mpack_node_data_t* node) {
+    mpack_log("parsing a node at position %i in level %i\n",
+            (int)tree->size, (int)tree->parser.level);
+
+    if (!mpack_tree_parse_node_contents(tree, node)) {
+        mpack_log("node parsing returned false\n");
+        return false;
+    }
+
+    tree->parser.possible_nodes_left -= tree->parser.current_node_reserved;
+
+    // The reserve for the current node does not include the initial byte
+    // previously reserved as part of its parent.
+    size_t node_size = tree->parser.current_node_reserved + 1;
+
+    // If the parsed type is a map or array, the reserve includes one byte for
+    // each child. We want to subtract these out of possible_nodes_left, but
+    // not out of the current size of the tree.
+    if (node->type == mpack_type_array)
+        node_size -= node->len;
+    else if (node->type == mpack_type_map)
+        node_size -= node->len * 2;
+    tree->size += node_size;
+
+    mpack_log("parsed a node of type %s of %i bytes and "
+            "%i additional bytes reserved for children.\n",
+            mpack_type_to_string(node->type), (int)node_size,
+            (int)tree->parser.current_node_reserved + 1 - (int)node_size);
+
+    return true;
+}
+
+/*
+ * We read nodes in a loop instead of recursively for maximum performance. The
+ * stack holds the amount of children left to read in each level of the tree.
+ * Parsing can pause and resume when more data becomes available.
+ */
+static bool mpack_tree_continue_parsing(mpack_tree_t* tree) {
+    if (mpack_tree_error(tree) != mpack_ok)
+        return false;
+
+    mpack_tree_parser_t* parser = &tree->parser;
+    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
+    mpack_log("parsing tree elements, %i bytes in buffer\n", (int)tree->data_length);
+
+    // we loop parsing nodes until the parse stack is empty. we break
+    // by returning out of the function.
+    while (true) {
+        mpack_node_data_t* node = parser->stack[parser->level].child;
+        size_t level = parser->level;
+        if (!mpack_tree_parse_node(tree, node))
+            return false;
+        --parser->stack[level].left;
+        ++parser->stack[level].child;
+
+        mpack_assert(mpack_tree_error(tree) == mpack_ok,
+                "mpack_tree_parse_node() should have returned false due to error!");
+
+        // pop empty stack levels, exiting the outer loop when the stack is empty.
+        // (we could tail-optimize containers by pre-emptively popping empty
+        // stack levels before reading the new element, this way we wouldn't
+        // have to loop. but we eventually want to use the parse stack to give
+        // better error messages that contain the location of the error, so
+        // it needs to be complete.)
+        while (parser->stack[parser->level].left == 0) {
+            if (parser->level == 0)
+                return true;
+            --parser->level;
+        }
+    }
+}
+
+static void mpack_tree_cleanup(mpack_tree_t* tree) {
+    MPACK_UNUSED(tree);
+
+    #ifdef MPACK_MALLOC
+    if (tree->parser.stack_owned) {
+        MPACK_FREE(tree->parser.stack);
+        tree->parser.stack = NULL;
+        tree->parser.stack_owned = false;
+    }
+
+    mpack_tree_page_t* page = tree->next;
+    while (page != NULL) {
+        mpack_tree_page_t* next = page->next;
+        mpack_log("freeing page %p\n", (void*)page);
+        MPACK_FREE(page);
+        page = next;
+    }
+    tree->next = NULL;
+    #endif
+}
+
+static bool mpack_tree_parse_start(mpack_tree_t* tree) {
+    if (mpack_tree_error(tree) != mpack_ok)
+        return false;
+
+    mpack_tree_parser_t* parser = &tree->parser;
+    mpack_assert(parser->state != mpack_tree_parse_state_in_progress,
+            "previous parsing was not finished!");
+
+    if (parser->state == mpack_tree_parse_state_parsed)
+        mpack_tree_cleanup(tree);
+
+    mpack_log("starting parse\n");
+    tree->parser.state = mpack_tree_parse_state_in_progress;
+    tree->parser.current_node_reserved = 0;
+
+    // check if we previously parsed a tree
+    if (tree->size > 0) {
+        #ifdef MPACK_MALLOC
+        // if we're buffered, move the remaining data back to the
+        // start of the buffer
+        // TODO: This is not ideal performance-wise. We should only move data
+        // when we need to call the fill function.
+        // TODO: We could consider shrinking the buffer here, especially if we
+        // determine that the fill function is providing less than a quarter of
+        // the buffer size or if messages take up less than a quarter of the
+        // buffer size. Maybe this should be configurable.
+        if (tree->buffer != NULL) {
+            mpack_memmove(tree->buffer, tree->buffer + tree->size, tree->data_length - tree->size);
+        }
+        else
+        #endif
+        // otherwise advance past the parsed data
+        {
+            tree->data += tree->size;
+        }
+        tree->data_length -= tree->size;
+        tree->size = 0;
+        tree->node_count = 0;
+    }
+
+    // make sure we have at least one byte available before allocating anything
+    parser->possible_nodes_left = tree->data_length;
+    if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) {
+        tree->parser.state = mpack_tree_parse_state_not_started;
+        return false;
+    }
+    mpack_log("parsing tree at %p starting with byte %x\n", tree->data, (uint8_t)tree->data[0]);
+    parser->possible_nodes_left -= 1;
+    tree->node_count = 1;
+
+    #ifdef MPACK_MALLOC
+    parser->stack = parser->stack_local;
+    parser->stack_owned = false;
+    parser->stack_capacity = sizeof(parser->stack_local) / sizeof(*parser->stack_local);
+
+    if (tree->pool == NULL) {
+
+        // allocate first page
+        mpack_tree_page_t* page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE);
+        mpack_log("allocated initial page %p of size %i count %i\n",
+                (void*)page, (int)MPACK_PAGE_ALLOC_SIZE, (int)MPACK_NODES_PER_PAGE);
+        if (page == NULL) {
+            tree->error = mpack_error_memory;
+            return false;
+        }
+        page->next = NULL;
+        tree->next = page;
+
+        parser->nodes = page->nodes;
+        parser->nodes_left = MPACK_NODES_PER_PAGE;
+    }
+    else
+    #endif
+    {
+        // otherwise use the provided pool
+        mpack_assert(tree->pool != NULL, "no pool provided?");
+        parser->nodes = tree->pool;
+        parser->nodes_left = tree->pool_count;
+    }
+
+    tree->root = parser->nodes;
+    ++parser->nodes;
+    --parser->nodes_left;
+
+    parser->level = 0;
+    parser->stack[0].child = tree->root;
+    parser->stack[0].left = 1;
+
+    return true;
+}
+
+void mpack_tree_parse(mpack_tree_t* tree) {
+    if (mpack_tree_error(tree) != mpack_ok)
+        return;
+
+    if (tree->parser.state != mpack_tree_parse_state_in_progress) {
+        if (!mpack_tree_parse_start(tree)) {
+            mpack_tree_flag_error(tree, (tree->read_fn == NULL) ?
+                    mpack_error_invalid : mpack_error_io);
+            return;
+        }
+    }
+
+    if (!mpack_tree_continue_parsing(tree)) {
+        if (mpack_tree_error(tree) != mpack_ok)
+            return;
+
+        // We're parsing synchronously on a blocking fill function. If we
+        // didn't completely finish parsing the tree, it's an error.
+        mpack_log("tree parsing incomplete. flagging error.\n");
+        mpack_tree_flag_error(tree, (tree->read_fn == NULL) ?
+                mpack_error_invalid : mpack_error_io);
+        return;
+    }
+
+    mpack_assert(mpack_tree_error(tree) == mpack_ok);
+    mpack_assert(tree->parser.level == 0);
+    tree->parser.state = mpack_tree_parse_state_parsed;
+    mpack_log("parsed tree of %i bytes, %i bytes left\n", (int)tree->size, (int)tree->parser.possible_nodes_left);
+    mpack_log("%i nodes in final page\n", (int)tree->parser.nodes_left);
+}
+
+bool mpack_tree_try_parse(mpack_tree_t* tree) {
+    if (mpack_tree_error(tree) != mpack_ok)
+        return false;
+
+    if (tree->parser.state != mpack_tree_parse_state_in_progress)
+        if (!mpack_tree_parse_start(tree))
+            return false;
+
+    if (!mpack_tree_continue_parsing(tree))
+        return false;
+
+    mpack_assert(mpack_tree_error(tree) == mpack_ok);
+    mpack_assert(tree->parser.level == 0);
+    tree->parser.state = mpack_tree_parse_state_parsed;
+    return true;
+}
+
+
+
+/*
+ * Tree functions
+ */
+
+mpack_node_t mpack_tree_root(mpack_tree_t* tree) {
+    if (mpack_tree_error(tree) != mpack_ok)
+        return mpack_tree_nil_node(tree);
+
+    // We check that a tree was parsed successfully and assert if not. You must
+    // call mpack_tree_parse() (or mpack_tree_try_parse() with a success
+    // result) in order to access the root node.
+    if (tree->parser.state != mpack_tree_parse_state_parsed) {
+        mpack_break("Tree has not been parsed! "
+                "Did you call mpack_tree_parse() or mpack_tree_try_parse()?");
+        mpack_tree_flag_error(tree, mpack_error_bug);
+        return mpack_tree_nil_node(tree);
+    }
+
+    return mpack_node(tree, tree->root);
+}
+
+static void mpack_tree_init_clear(mpack_tree_t* tree) {
+    mpack_memset(tree, 0, sizeof(*tree));
+    tree->nil_node.type = mpack_type_nil;
+    tree->missing_node.type = mpack_type_missing;
+    tree->max_size = SIZE_MAX;
+    tree->max_nodes = SIZE_MAX;
+}
+
+#ifdef MPACK_MALLOC
+void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length) {
+    mpack_tree_init_clear(tree);
+
+    MPACK_STATIC_ASSERT(MPACK_NODE_PAGE_SIZE >= sizeof(mpack_tree_page_t),
+            "MPACK_NODE_PAGE_SIZE is too small");
+
+    MPACK_STATIC_ASSERT(MPACK_PAGE_ALLOC_SIZE <= MPACK_NODE_PAGE_SIZE,
+            "incorrect page rounding?");
+
+    tree->data = data;
+    tree->data_length = length;
+    tree->pool = NULL;
+    tree->pool_count = 0;
+    tree->next = NULL;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing tree with data of size %i\n", (int)length);
+}
+#endif
+
+void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length,
+        mpack_node_data_t* node_pool, size_t node_pool_count)
+{
+    mpack_tree_init_clear(tree);
+    #ifdef MPACK_MALLOC
+    tree->next = NULL;
+    #endif
+
+    if (node_pool_count == 0) {
+        mpack_break("initial page has no nodes!");
+        mpack_tree_flag_error(tree, mpack_error_bug);
+        return;
+    }
+
+    tree->data = data;
+    tree->data_length = length;
+    tree->pool = node_pool;
+    tree->pool_count = node_pool_count;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing tree with data of size %i and pool of count %i\n",
+            (int)length, (int)node_pool_count);
+}
+
+void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error) {
+    mpack_tree_init_clear(tree);
+    tree->error = error;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing tree error state %i\n", (int)error);
+}
+
+#ifdef MPACK_MALLOC
+void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context,
+        size_t max_message_size, size_t max_message_nodes) {
+    mpack_tree_init_clear(tree);
+
+    tree->read_fn = read_fn;
+    tree->context = context;
+
+    mpack_tree_set_limits(tree, max_message_size, max_message_nodes);
+    tree->max_size = max_message_size;
+    tree->max_nodes = max_message_nodes;
+
+    mpack_log("===========================\n");
+    mpack_log("initializing tree with stream, max size %i max nodes %i\n",
+            (int)max_message_size, (int)max_message_nodes);
+}
+#endif
+
+void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size, size_t max_message_nodes) {
+    mpack_assert(max_message_size > 0);
+    mpack_assert(max_message_nodes > 0);
+    tree->max_size = max_message_size;
+    tree->max_nodes = max_message_nodes;
+}
+
+#if MPACK_STDIO
+typedef struct mpack_file_tree_t {
+    char* data;
+    size_t size;
+    char buffer[MPACK_BUFFER_SIZE];
+} mpack_file_tree_t;
+
+static void mpack_file_tree_teardown(mpack_tree_t* tree) {
+    mpack_file_tree_t* file_tree = (mpack_file_tree_t*)tree->context;
+    MPACK_FREE(file_tree->data);
+    MPACK_FREE(file_tree);
+}
+
+static bool mpack_file_tree_read(mpack_tree_t* tree, mpack_file_tree_t* file_tree, FILE* file, size_t max_bytes) {
+
+    // get the file size
+    errno = 0;
+    int error = 0;
+    fseek(file, 0, SEEK_END);
+    error |= errno;
+    long size = ftell(file);
+    error |= errno;
+    fseek(file, 0, SEEK_SET);
+    error |= errno;
+
+    // check for errors
+    if (error != 0 || size < 0) {
+        mpack_tree_init_error(tree, mpack_error_io);
+        return false;
+    }
+    if (size == 0) {
+        mpack_tree_init_error(tree, mpack_error_invalid);
+        return false;
+    }
+
+    // make sure the size is less than max_bytes
+    // (this mess exists to safely convert between long and size_t regardless of their widths)
+    if (max_bytes != 0 && (((uint64_t)LONG_MAX > (uint64_t)SIZE_MAX && size > (long)SIZE_MAX) || (size_t)size > max_bytes)) {
+        mpack_tree_init_error(tree, mpack_error_too_big);
+        return false;
+    }
+
+    // allocate data
+    file_tree->data = (char*)MPACK_MALLOC((size_t)size);
+    if (file_tree->data == NULL) {
+        mpack_tree_init_error(tree, mpack_error_memory);
+        return false;
+    }
+
+    // read the file
+    long total = 0;
+    while (total < size) {
+        size_t read = fread(file_tree->data + total, 1, (size_t)(size - total), file);
+        if (read <= 0) {
+            mpack_tree_init_error(tree, mpack_error_io);
+            MPACK_FREE(file_tree->data);
+            return false;
+        }
+        total += (long)read;
+    }
+
+    file_tree->size = (size_t)size;
+    return true;
+}
+
+static bool mpack_tree_file_check_max_bytes(mpack_tree_t* tree, size_t max_bytes) {
+
+    // the C STDIO family of file functions use long (e.g. ftell)
+    if (max_bytes > LONG_MAX) {
+        mpack_break("max_bytes of %" PRIu64 " is invalid, maximum is LONG_MAX", (uint64_t)max_bytes);
+        mpack_tree_init_error(tree, mpack_error_bug);
+        return false;
+    }
+
+    return true;
+}
+
+static void mpack_tree_init_stdfile_noclose(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes) {
+
+    // allocate file tree
+    mpack_file_tree_t* file_tree = (mpack_file_tree_t*) MPACK_MALLOC(sizeof(mpack_file_tree_t));
+    if (file_tree == NULL) {
+        mpack_tree_init_error(tree, mpack_error_memory);
+        return;
+    }
+
+    // read all data
+    if (!mpack_file_tree_read(tree, file_tree, stdfile, max_bytes)) {
+        MPACK_FREE(file_tree);
+        return;
+    }
+
+    mpack_tree_init_data(tree, file_tree->data, file_tree->size);
+    mpack_tree_set_context(tree, file_tree);
+    mpack_tree_set_teardown(tree, mpack_file_tree_teardown);
+}
+
+void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done) {
+    if (!mpack_tree_file_check_max_bytes(tree, max_bytes))
+        return;
+
+    mpack_tree_init_stdfile_noclose(tree, stdfile, max_bytes);
+
+    if (close_when_done)
+        fclose(stdfile);
+}
+
+void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes) {
+    if (!mpack_tree_file_check_max_bytes(tree, max_bytes))
+        return;
+
+    // open the file
+    FILE* file = fopen(filename, "rb");
+    if (!file) {
+        mpack_tree_init_error(tree, mpack_error_io);
+        return;
+    }
+
+    mpack_tree_init_stdfile(tree, file, max_bytes, true);
+}
+#endif
+
+mpack_error_t mpack_tree_destroy(mpack_tree_t* tree) {
+    mpack_tree_cleanup(tree);
+
+    #ifdef MPACK_MALLOC
+    if (tree->buffer)
+        MPACK_FREE(tree->buffer);
+    #endif
+
+    if (tree->teardown)
+        tree->teardown(tree);
+    tree->teardown = NULL;
+
+    return tree->error;
+}
+
+void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error) {
+    if (tree->error == mpack_ok) {
+        mpack_log("tree %p setting error %i: %s\n", (void*)tree, (int)error, mpack_error_to_string(error));
+        tree->error = error;
+        if (tree->error_fn)
+            tree->error_fn(tree, error);
+    }
+
+}
+
+
+
+/*
+ * Node misc functions
+ */
+
+void mpack_node_flag_error(mpack_node_t node, mpack_error_t error) {
+    mpack_tree_flag_error(node.tree, error);
+}
+
+mpack_tag_t mpack_node_tag(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return mpack_tag_nil();
+
+    mpack_tag_t tag = MPACK_TAG_ZERO;
+
+    tag.type = node.data->type;
+    switch (node.data->type) {
+        case mpack_type_missing:
+            // If a node is missing, I don't know if it makes sense to ask for
+            // a tag for it. We'll return a missing tag to match the missing
+            // node I guess, but attempting to use the tag for anything (like
+            // writing it for example) will flag mpack_error_bug.
+            break;
+        case mpack_type_nil:                                            break;
+        case mpack_type_bool:    tag.v.b = node.data->value.b;          break;
+        case mpack_type_float:   tag.v.f = node.data->value.f;          break;
+        case mpack_type_double:  tag.v.d = node.data->value.d;          break;
+        case mpack_type_int:     tag.v.i = node.data->value.i;          break;
+        case mpack_type_uint:    tag.v.u = node.data->value.u;          break;
+
+        case mpack_type_str:     tag.v.l = node.data->len;     break;
+        case mpack_type_bin:     tag.v.l = node.data->len;     break;
+
+        #if MPACK_EXTENSIONS
+        case mpack_type_ext:
+            tag.v.l = node.data->len;
+            tag.exttype = mpack_node_exttype_unchecked(node);
+            break;
+        #endif
+
+        case mpack_type_array:   tag.v.n = node.data->len;  break;
+        case mpack_type_map:     tag.v.n = node.data->len;  break;
+
+        default:
+            mpack_assert(0, "unrecognized type %i", (int)node.data->type);
+            break;
+    }
+    return tag;
+}
+
+#if MPACK_DEBUG && MPACK_STDIO
+static void mpack_node_print_element(mpack_node_t node, mpack_print_t* print, size_t depth) {
+    mpack_node_data_t* data = node.data;
+    switch (data->type) {
+        case mpack_type_str:
+            {
+                mpack_print_append_cstr(print, "\"");
+                const char* bytes = mpack_node_data_unchecked(node);
+                for (size_t i = 0; i < data->len; ++i) {
+                    char c = bytes[i];
+                    switch (c) {
+                        case '\n': mpack_print_append_cstr(print, "\\n"); break;
+                        case '\\': mpack_print_append_cstr(print, "\\\\"); break;
+                        case '"': mpack_print_append_cstr(print, "\\\""); break;
+                        default: mpack_print_append(print, &c, 1); break;
+                    }
+                }
+                mpack_print_append_cstr(print, "\"");
+            }
+            break;
+
+        case mpack_type_array:
+            mpack_print_append_cstr(print, "[\n");
+            for (size_t i = 0; i < data->len; ++i) {
+                for (size_t j = 0; j < depth + 1; ++j)
+                    mpack_print_append_cstr(print, "    ");
+                mpack_node_print_element(mpack_node_array_at(node, i), print, depth + 1);
+                if (i != data->len - 1)
+                    mpack_print_append_cstr(print, ",");
+                mpack_print_append_cstr(print, "\n");
+            }
+            for (size_t i = 0; i < depth; ++i)
+                mpack_print_append_cstr(print, "    ");
+            mpack_print_append_cstr(print, "]");
+            break;
+
+        case mpack_type_map:
+            mpack_print_append_cstr(print, "{\n");
+            for (size_t i = 0; i < data->len; ++i) {
+                for (size_t j = 0; j < depth + 1; ++j)
+                    mpack_print_append_cstr(print, "    ");
+                mpack_node_print_element(mpack_node_map_key_at(node, i), print, depth + 1);
+                mpack_print_append_cstr(print, ": ");
+                mpack_node_print_element(mpack_node_map_value_at(node, i), print, depth + 1);
+                if (i != data->len - 1)
+                    mpack_print_append_cstr(print, ",");
+                mpack_print_append_cstr(print, "\n");
+            }
+            for (size_t i = 0; i < depth; ++i)
+                mpack_print_append_cstr(print, "    ");
+            mpack_print_append_cstr(print, "}");
+            break;
+
+        default:
+            {
+                const char* prefix = NULL;
+                size_t prefix_length = 0;
+                if (mpack_node_type(node) == mpack_type_bin
+                        #if MPACK_EXTENSIONS
+                        || mpack_node_type(node) == mpack_type_ext
+                        #endif
+                ) {
+                    prefix = mpack_node_data(node);
+                    prefix_length = mpack_node_data_len(node);
+                }
+
+                char buf[256];
+                mpack_tag_t tag = mpack_node_tag(node);
+                mpack_tag_debug_pseudo_json(tag, buf, sizeof(buf), prefix, prefix_length);
+                mpack_print_append_cstr(print, buf);
+            }
+            break;
+    }
+}
+
+void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size) {
+    if (buffer_size == 0) {
+        mpack_assert(false, "buffer size is zero!");
+        return;
+    }
+
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = buffer_size;
+    mpack_node_print_element(node, &print, 0);
+    mpack_print_append(&print, "",  1); // null-terminator
+    mpack_print_flush(&print);
+
+    // we always make sure there's a null-terminator at the end of the buffer
+    // in case we ran out of space.
+    print.buffer[print.size - 1] = '\0';
+}
+
+void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context) {
+    char buffer[1024];
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = sizeof(buffer);
+    print.callback = callback;
+    print.context = context;
+    mpack_node_print_element(node, &print, 0);
+    mpack_print_flush(&print);
+}
+
+void mpack_node_print_to_file(mpack_node_t node, FILE* file) {
+    mpack_assert(file != NULL, "file is NULL");
+
+    char buffer[1024];
+    mpack_print_t print;
+    mpack_memset(&print, 0, sizeof(print));
+    print.buffer = buffer;
+    print.size = sizeof(buffer);
+    print.callback = &mpack_print_file_callback;
+    print.context = file;
+
+    size_t depth = 2;
+    for (size_t i = 0; i < depth; ++i)
+        mpack_print_append_cstr(&print, "    ");
+    mpack_node_print_element(node, &print, depth);
+    mpack_print_append_cstr(&print, "\n");
+    mpack_print_flush(&print);
+}
+#endif
+ 
+
+ 
+/*
+ * Node Value Functions
+ */
+
+#if MPACK_EXTENSIONS
+mpack_timestamp_t mpack_node_timestamp(mpack_node_t node) {
+    mpack_timestamp_t timestamp = {0, 0};
+
+    // we'll let mpack_node_exttype() do most checks
+    if (mpack_node_exttype(node) != MPACK_EXTTYPE_TIMESTAMP) {
+        mpack_log("exttype %i\n", mpack_node_exttype(node));
+        mpack_node_flag_error(node, mpack_error_type);
+        return timestamp;
+    }
+
+    const char* p = mpack_node_data_unchecked(node);
+
+    switch (node.data->len) {
+        case 4:
+            timestamp.nanoseconds = 0;
+            timestamp.seconds = mpack_load_u32(p);
+            break;
+
+        case 8: {
+            uint64_t value = mpack_load_u64(p);
+            timestamp.nanoseconds = (uint32_t)(value >> 34);
+            timestamp.seconds = value & ((UINT64_C(1) << 34) - 1);
+            break;
+        }
+
+        case 12:
+            timestamp.nanoseconds = mpack_load_u32(p);
+            timestamp.seconds = mpack_load_i64(p + 4);
+            break;
+
+        default:
+            mpack_tree_flag_error(node.tree, mpack_error_invalid);
+            return timestamp;
+    }
+
+    if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
+        mpack_tree_flag_error(node.tree, mpack_error_invalid);
+        mpack_timestamp_t zero = {0, 0};
+        return zero;
+    }
+
+    return timestamp;
+}
+
+int64_t mpack_node_timestamp_seconds(mpack_node_t node) {
+    return mpack_node_timestamp(node).seconds;
+}
+
+uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node) {
+    return mpack_node_timestamp(node).nanoseconds;
+}
+#endif
+
+
+
+/*
+ * Node Data Functions
+ */
+
+void mpack_node_check_utf8(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return;
+    mpack_node_data_t* data = node.data;
+    if (data->type != mpack_type_str || !mpack_utf8_check(mpack_node_data_unchecked(node), data->len))
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+void mpack_node_check_utf8_cstr(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return;
+    mpack_node_data_t* data = node.data;
+    if (data->type != mpack_type_str || !mpack_utf8_check_no_null(mpack_node_data_unchecked(node), data->len))
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize);
+
+    mpack_type_t type = node.data->type;
+    if (type != mpack_type_str && type != mpack_type_bin
+            #if MPACK_EXTENSIONS
+            && type != mpack_type_ext
+            #endif
+    ) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return 0;
+    }
+
+    if (node.data->len > bufsize) {
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return 0;
+    }
+
+    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
+    return (size_t)node.data->len;
+}
+
+size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize);
+
+    mpack_type_t type = node.data->type;
+    if (type != mpack_type_str) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return 0;
+    }
+
+    if (node.data->len > bufsize) {
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return 0;
+    }
+
+    if (!mpack_utf8_check(mpack_node_data_unchecked(node), node.data->len)) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return 0;
+    }
+
+    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
+    return (size_t)node.data->len;
+}
+
+void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t bufsize) {
+
+    // we can't break here because the error isn't recoverable; we
+    // have to add a null-terminator.
+    mpack_assert(buffer != NULL, "buffer is NULL");
+    mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator");
+
+    if (mpack_node_error(node) != mpack_ok) {
+        buffer[0] = '\0';
+        return;
+    }
+
+    if (node.data->type != mpack_type_str) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_type);
+        return;
+    }
+
+    if (node.data->len > bufsize - 1) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return;
+    }
+
+    if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_type);
+        return;
+    }
+
+    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
+    buffer[node.data->len] = '\0';
+}
+
+void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t bufsize) {
+
+    // we can't break here because the error isn't recoverable; we
+    // have to add a null-terminator.
+    mpack_assert(buffer != NULL, "buffer is NULL");
+    mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator");
+
+    if (mpack_node_error(node) != mpack_ok) {
+        buffer[0] = '\0';
+        return;
+    }
+
+    if (node.data->type != mpack_type_str) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_type);
+        return;
+    }
+
+    if (node.data->len > bufsize - 1) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return;
+    }
+
+    if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
+        buffer[0] = '\0';
+        mpack_node_flag_error(node, mpack_error_type);
+        return;
+    }
+
+    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
+    buffer[node.data->len] = '\0';
+}
+
+#ifdef MPACK_MALLOC
+char* mpack_node_data_alloc(mpack_node_t node, size_t maxlen) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    // make sure this is a valid data type
+    mpack_type_t type = node.data->type;
+    if (type != mpack_type_str && type != mpack_type_bin
+            #if MPACK_EXTENSIONS
+            && type != mpack_type_ext
+            #endif
+    ) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    if (node.data->len > maxlen) {
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return NULL;
+    }
+
+    char* ret = (char*) MPACK_MALLOC((size_t)node.data->len);
+    if (ret == NULL) {
+        mpack_node_flag_error(node, mpack_error_memory);
+        return NULL;
+    }
+
+    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
+    return ret;
+}
+
+char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxlen) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    // make sure maxlen makes sense
+    if (maxlen < 1) {
+        mpack_break("maxlen is zero; you must have room for at least a null-terminator");
+        mpack_node_flag_error(node, mpack_error_bug);
+        return NULL;
+    }
+
+    if (node.data->type != mpack_type_str) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    if (node.data->len > maxlen - 1) {
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return NULL;
+    }
+
+    if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1));
+    if (ret == NULL) {
+        mpack_node_flag_error(node, mpack_error_memory);
+        return NULL;
+    }
+
+    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
+    ret[node.data->len] = '\0';
+    return ret;
+}
+
+char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxlen) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    // make sure maxlen makes sense
+    if (maxlen < 1) {
+        mpack_break("maxlen is zero; you must have room for at least a null-terminator");
+        mpack_node_flag_error(node, mpack_error_bug);
+        return NULL;
+    }
+
+    if (node.data->type != mpack_type_str) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    if (node.data->len > maxlen - 1) {
+        mpack_node_flag_error(node, mpack_error_too_big);
+        return NULL;
+    }
+
+    if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1));
+    if (ret == NULL) {
+        mpack_node_flag_error(node, mpack_error_memory);
+        return NULL;
+    }
+
+    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
+    ret[node.data->len] = '\0';
+    return ret;
+}
+#endif
+
+
+/*
+ * Compound Node Functions
+ */
+
+static mpack_node_data_t* mpack_node_map_int_impl(mpack_node_t node, int64_t num) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    if (node.data->type != mpack_type_map) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    mpack_node_data_t* found = NULL;
+
+    for (size_t i = 0; i < node.data->len; ++i) {
+        mpack_node_data_t* key = mpack_node_child(node, i * 2);
+
+        if ((key->type == mpack_type_int && key->value.i == num) ||
+            (key->type == mpack_type_uint && num >= 0 && key->value.u == (uint64_t)num))
+        {
+            if (found) {
+                mpack_node_flag_error(node, mpack_error_data);
+                return NULL;
+            }
+            found = mpack_node_child(node, i * 2 + 1);
+        }
+    }
+
+    if (found)
+        return found;
+
+    return NULL;
+}
+
+static mpack_node_data_t* mpack_node_map_uint_impl(mpack_node_t node, uint64_t num) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    if (node.data->type != mpack_type_map) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    mpack_node_data_t* found = NULL;
+
+    for (size_t i = 0; i < node.data->len; ++i) {
+        mpack_node_data_t* key = mpack_node_child(node, i * 2);
+
+        if ((key->type == mpack_type_uint && key->value.u == num) ||
+            (key->type == mpack_type_int && key->value.i >= 0 && (uint64_t)key->value.i == num))
+        {
+            if (found) {
+                mpack_node_flag_error(node, mpack_error_data);
+                return NULL;
+            }
+            found = mpack_node_child(node, i * 2 + 1);
+        }
+    }
+
+    if (found)
+        return found;
+
+    return NULL;
+}
+
+static mpack_node_data_t* mpack_node_map_str_impl(mpack_node_t node, const char* str, size_t length) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    mpack_assert(length == 0 || str != NULL, "str of length %i is NULL", (int)length);
+
+    if (node.data->type != mpack_type_map) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return NULL;
+    }
+
+    mpack_tree_t* tree = node.tree;
+    mpack_node_data_t* found = NULL;
+
+    for (size_t i = 0; i < node.data->len; ++i) {
+        mpack_node_data_t* key = mpack_node_child(node, i * 2);
+
+        if (key->type == mpack_type_str && key->len == length &&
+                mpack_memcmp(str, mpack_node_data_unchecked(mpack_node(tree, key)), length) == 0) {
+            if (found) {
+                mpack_node_flag_error(node, mpack_error_data);
+                return NULL;
+            }
+            found = mpack_node_child(node, i * 2 + 1);
+        }
+    }
+
+    if (found)
+        return found;
+
+    return NULL;
+}
+
+static mpack_node_t mpack_node_wrap_lookup(mpack_tree_t* tree, mpack_node_data_t* data) {
+    if (!data) {
+        if (tree->error == mpack_ok)
+            mpack_tree_flag_error(tree, mpack_error_data);
+        return mpack_tree_nil_node(tree);
+    }
+    return mpack_node(tree, data);
+}
+
+static mpack_node_t mpack_node_wrap_lookup_optional(mpack_tree_t* tree, mpack_node_data_t* data) {
+    if (!data) {
+        if (tree->error == mpack_ok)
+            return mpack_tree_missing_node(tree);
+        return mpack_tree_nil_node(tree);
+    }
+    return mpack_node(tree, data);
+}
+
+mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num) {
+    return mpack_node_wrap_lookup(node.tree, mpack_node_map_int_impl(node, num));
+}
+
+mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num) {
+    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_int_impl(node, num));
+}
+
+mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num) {
+    return mpack_node_wrap_lookup(node.tree, mpack_node_map_uint_impl(node, num));
+}
+
+mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num) {
+    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_uint_impl(node, num));
+}
+
+mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length) {
+    return mpack_node_wrap_lookup(node.tree, mpack_node_map_str_impl(node, str, length));
+}
+
+mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length) {
+    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_str_impl(node, str, length));
+}
+
+mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr is NULL");
+    return mpack_node_map_str(node, cstr, mpack_strlen(cstr));
+}
+
+mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr is NULL");
+    return mpack_node_map_str_optional(node, cstr, mpack_strlen(cstr));
+}
+
+bool mpack_node_map_contains_int(mpack_node_t node, int64_t num) {
+    return mpack_node_map_int_impl(node, num) != NULL;
+}
+
+bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num) {
+    return mpack_node_map_uint_impl(node, num) != NULL;
+}
+
+bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length) {
+    return mpack_node_map_str_impl(node, str, length) != NULL;
+}
+
+bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr is NULL");
+    return mpack_node_map_contains_str(node, cstr, mpack_strlen(cstr));
+}
+
+size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count) {
+    if (mpack_node_error(node) != mpack_ok)
+        return count;
+
+    // the value is only recognized if it is a string
+    if (mpack_node_type(node) != mpack_type_str)
+        return count;
+
+    // fetch the string
+    const char* key = mpack_node_str(node);
+    size_t keylen = mpack_node_strlen(node);
+    mpack_assert(mpack_node_error(node) == mpack_ok, "these should not fail");
+
+    // find what key it matches
+    for (size_t i = 0; i < count; ++i) {
+        const char* other = strings[i];
+        size_t otherlen = mpack_strlen(other);
+        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
+            return i;
+    }
+
+    // no matches
+    return count;
+}
+
+size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count) {
+    size_t value = mpack_node_enum_optional(node, strings, count);
+    if (value == count)
+        mpack_node_flag_error(node, mpack_error_type);
+    return value;
+}
+
+mpack_type_t mpack_node_type(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return mpack_type_nil;
+    return node.data->type;
+}
+
+bool mpack_node_is_nil(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok) {
+        // All nodes are treated as nil nodes when we are in error.
+        return true;
+    }
+    return node.data->type == mpack_type_nil;
+}
+
+bool mpack_node_is_missing(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok) {
+        // errors still return nil nodes, not missing nodes.
+        return false;
+    }
+    return node.data->type == mpack_type_missing;
+}
+
+void mpack_node_nil(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return;
+    if (node.data->type != mpack_type_nil)
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+void mpack_node_missing(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return;
+    if (node.data->type != mpack_type_missing)
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+bool mpack_node_bool(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return false;
+
+    if (node.data->type == mpack_type_bool)
+        return node.data->value.b;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return false;
+}
+
+void mpack_node_true(mpack_node_t node) {
+    if (mpack_node_bool(node) != true)
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+void mpack_node_false(mpack_node_t node) {
+    if (mpack_node_bool(node) != false)
+        mpack_node_flag_error(node, mpack_error_type);
+}
+
+uint8_t mpack_node_u8(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= UINT8_MAX)
+            return (uint8_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= 0 && node.data->value.i <= UINT8_MAX)
+            return (uint8_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+int8_t mpack_node_i8(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= INT8_MAX)
+            return (int8_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= INT8_MIN && node.data->value.i <= INT8_MAX)
+            return (int8_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+uint16_t mpack_node_u16(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= UINT16_MAX)
+            return (uint16_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= 0 && node.data->value.i <= UINT16_MAX)
+            return (uint16_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+int16_t mpack_node_i16(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= INT16_MAX)
+            return (int16_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= INT16_MIN && node.data->value.i <= INT16_MAX)
+            return (int16_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+uint32_t mpack_node_u32(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= UINT32_MAX)
+            return (uint32_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= 0 && node.data->value.i <= UINT32_MAX)
+            return (uint32_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+int32_t mpack_node_i32(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= INT32_MAX)
+            return (int32_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= INT32_MIN && node.data->value.i <= INT32_MAX)
+            return (int32_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+uint64_t mpack_node_u64(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        return node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        if (node.data->value.i >= 0)
+            return (uint64_t)node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+int64_t mpack_node_i64(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_uint) {
+        if (node.data->value.u <= (uint64_t)INT64_MAX)
+            return (int64_t)node.data->value.u;
+    } else if (node.data->type == mpack_type_int) {
+        return node.data->value.i;
+    }
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+unsigned int mpack_node_uint(mpack_node_t node) {
+
+    // This should be true at compile-time, so this just wraps the 32-bit function.
+    if (sizeof(unsigned int) == 4)
+        return (unsigned int)mpack_node_u32(node);
+
+    // Otherwise we use u64 and check the range.
+    uint64_t val = mpack_node_u64(node);
+    if (val <= UINT_MAX)
+        return (unsigned int)val;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+int mpack_node_int(mpack_node_t node) {
+
+    // This should be true at compile-time, so this just wraps the 32-bit function.
+    if (sizeof(int) == 4)
+        return (int)mpack_node_i32(node);
+
+    // Otherwise we use i64 and check the range.
+    int64_t val = mpack_node_i64(node);
+    if (val >= INT_MIN && val <= INT_MAX)
+        return (int)val;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+float mpack_node_float(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0.0f;
+
+    if (node.data->type == mpack_type_uint)
+        return (float)node.data->value.u;
+    else if (node.data->type == mpack_type_int)
+        return (float)node.data->value.i;
+    else if (node.data->type == mpack_type_float)
+        return node.data->value.f;
+    else if (node.data->type == mpack_type_double)
+        return (float)node.data->value.d;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0.0f;
+}
+
+double mpack_node_double(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0.0;
+
+    if (node.data->type == mpack_type_uint)
+        return (double)node.data->value.u;
+    else if (node.data->type == mpack_type_int)
+        return (double)node.data->value.i;
+    else if (node.data->type == mpack_type_float)
+        return (double)node.data->value.f;
+    else if (node.data->type == mpack_type_double)
+        return node.data->value.d;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0.0;
+}
+
+float mpack_node_float_strict(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0.0f;
+
+    if (node.data->type == mpack_type_float)
+        return node.data->value.f;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0.0f;
+}
+
+double mpack_node_double_strict(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0.0;
+
+    if (node.data->type == mpack_type_float)
+        return (double)node.data->value.f;
+    else if (node.data->type == mpack_type_double)
+        return node.data->value.d;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0.0;
+}
+
+#if MPACK_EXTENSIONS
+int8_t mpack_node_exttype(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_ext)
+        return mpack_node_exttype_unchecked(node);
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+#endif
+
+uint32_t mpack_node_data_len(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    mpack_type_t type = node.data->type;
+    if (type == mpack_type_str || type == mpack_type_bin
+            #if MPACK_EXTENSIONS
+            || type == mpack_type_ext
+            #endif
+            )
+        return (uint32_t)node.data->len;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+size_t mpack_node_strlen(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_str)
+        return (size_t)node.data->len;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+const char* mpack_node_str(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    mpack_type_t type = node.data->type;
+    if (type == mpack_type_str)
+        return mpack_node_data_unchecked(node);
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return NULL;
+}
+
+const char* mpack_node_data(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    mpack_type_t type = node.data->type;
+    if (type == mpack_type_str || type == mpack_type_bin
+            #if MPACK_EXTENSIONS
+            || type == mpack_type_ext
+            #endif
+            )
+        return mpack_node_data_unchecked(node);
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return NULL;
+}
+
+const char* mpack_node_bin_data(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return NULL;
+
+    if (node.data->type == mpack_type_bin)
+        return mpack_node_data_unchecked(node);
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return NULL;
+}
+
+size_t mpack_node_bin_size(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type == mpack_type_bin)
+        return (size_t)node.data->len;
+
+    mpack_node_flag_error(node, mpack_error_type);
+    return 0;
+}
+
+size_t mpack_node_array_length(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type != mpack_type_array) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return 0;
+    }
+
+    return (size_t)node.data->len;
+}
+
+mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index) {
+    if (mpack_node_error(node) != mpack_ok)
+        return mpack_tree_nil_node(node.tree);
+
+    if (node.data->type != mpack_type_array) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return mpack_tree_nil_node(node.tree);
+    }
+
+    if (index >= node.data->len) {
+        mpack_node_flag_error(node, mpack_error_data);
+        return mpack_tree_nil_node(node.tree);
+    }
+
+    return mpack_node(node.tree, mpack_node_child(node, index));
+}
+
+size_t mpack_node_map_count(mpack_node_t node) {
+    if (mpack_node_error(node) != mpack_ok)
+        return 0;
+
+    if (node.data->type != mpack_type_map) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return 0;
+    }
+
+    return node.data->len;
+}
+
+// internal node map lookup
+static mpack_node_t mpack_node_map_at(mpack_node_t node, size_t index, size_t offset) {
+    if (mpack_node_error(node) != mpack_ok)
+        return mpack_tree_nil_node(node.tree);
+
+    if (node.data->type != mpack_type_map) {
+        mpack_node_flag_error(node, mpack_error_type);
+        return mpack_tree_nil_node(node.tree);
+    }
+
+    if (index >= node.data->len) {
+        mpack_node_flag_error(node, mpack_error_data);
+        return mpack_tree_nil_node(node.tree);
+    }
+
+    return mpack_node(node.tree, mpack_node_child(node, index * 2 + offset));
+}
+
+mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index) {
+    return mpack_node_map_at(node, index, 0);
+}
+
+mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index) {
+    return mpack_node_map_at(node, index, 1);
+}
+
+#endif
diff --git a/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.h b/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.h
new file mode 100644
index 000000000..7c0b3f17e
--- /dev/null
+++ b/fluent-bit/lib/ctraces/lib/mpack/src/mpack/mpack.h
@@ -0,0 +1,7203 @@
+/**
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2015-2018 Nicholas Fraser
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+
+/*
+ * This is the MPack 1.0 amalgamation package.
+ *
+ * http://github.com/ludocode/mpack
+ */
+
+#ifndef MPACK_H
+#define MPACK_H 1
+
+#define MPACK_AMALGAMATED 1
+
+#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG
+#include "mpack-config.h"
+#endif
+
+
+/* mpack/mpack-defaults.h.h */
+
+
+/**
+ * @name Features
+ * @{
+ */
+
+/**
+ * @def MPACK_READER
+ *
+ * Enables compilation of the base Tag Reader.
+ */
+#ifndef MPACK_READER
+#define MPACK_READER 1
+#endif
+
+/**
+ * @def MPACK_EXPECT
+ *
+ * Enables compilation of the static Expect API.
+ */
+#ifndef MPACK_EXPECT
+#define MPACK_EXPECT 1
+#endif
+
+/**
+ * @def MPACK_NODE
+ *
+ * Enables compilation of the dynamic Node API.
+ */
+#ifndef MPACK_NODE
+#define MPACK_NODE 1
+#endif
+
+/**
+ * @def MPACK_WRITER
+ *
+ * Enables compilation of the Writer.
+ */
+#ifndef MPACK_WRITER
+#define MPACK_WRITER 1
+#endif
+
+/**
+ * @def MPACK_COMPATIBILITY
+ *
+ * Enables compatibility features for reading and writing older
+ * versions of MessagePack.
+ *
+ * This is disabled by default. When disabled, the behaviour is equivalent to
+ * using the default version, @ref mpack_version_current.
+ *
+ * Enable this if you need to interoperate with applications or data that do
+ * not support the new (v5) MessagePack spec. See the section on v4
+ * compatibility in @ref docs/protocol.md for more information.
+ */
+#ifndef MPACK_COMPATIBILITY
+#define MPACK_COMPATIBILITY 0
+#endif
+
+/**
+ * @def MPACK_EXTENSIONS
+ *
+ * Enables the use of extension types.
+ *
+ * This is disabled by default. Define it to 1 to enable it. If disabled,
+ * functions to read and write extensions will not exist, and any occurrence of
+ * extension types in parsed messages will flag @ref mpack_error_invalid.
+ *
+ * MPack discourages the use of extension types. See the section on extension
+ * types in @ref docs/protocol.md for more information.
+ */
+#ifndef MPACK_EXTENSIONS
+#define MPACK_EXTENSIONS 0
+#endif
+
+
+/**
+ * @}
+ */
+
+
+/**
+ * @name Dependencies
+ * @{
+ */
+
+/**
+ * @def MPACK_HAS_CONFIG
+ *
+ * Enables the use of an @c mpack-config.h configuration file for MPack.
+ * This file must be in the same folder as @c mpack.h, or it must be
+ * available from your project's include paths.
+ */
+// This goes in your project settings.
+
+/**
+ * @def MPACK_STDLIB
+ *
+ * Enables the use of C stdlib. This allows the library to use malloc
+ * for debugging and in allocation helpers.
+ */
+#ifndef MPACK_STDLIB
+#define MPACK_STDLIB 1
+#endif
+
+/**
+ * @def MPACK_STDIO
+ *
+ * Enables the use of C stdio. This adds helpers for easily
+ * reading/writing C files and makes debugging easier.
+ */
+#ifndef MPACK_STDIO
+#define MPACK_STDIO 1
+#endif
+
+/**
+ * @}
+ */
+
+
+/**
+ * @name System Functions
+ * @{
+ */
+
+/**
+ * @def MPACK_MALLOC
+ *
+ * Defines the memory allocation function used by MPack. This is used by
+ * helpers for automatically allocating data the correct size, and for
+ * debugging functions. If this macro is undefined, the allocation helpers
+ * will not be compiled.
+ *
+ * The default is @c malloc() if @ref MPACK_STDLIB is enabled.
+ */
+/**
+ * @def MPACK_FREE
+ *
+ * Defines the memory free function used by MPack. This is used by helpers
+ * for automatically allocating data the correct size. If this macro is
+ * undefined, the allocation helpers will not be compiled.
+ *
+ * The default is @c free() if @ref MPACK_MALLOC has not been customized and
+ * @ref MPACK_STDLIB is enabled.
+ */
+/**
+ * @def MPACK_REALLOC
+ *
+ * Defines the realloc function used by MPack. It is used by growable
+ * buffers to resize more efficiently.
+ *
+ * The default is @c realloc() if @ref MPACK_MALLOC has not been customized and
+ * @ref MPACK_STDLIB is enabled.
+ *
+ * This is optional, even when @ref MPACK_MALLOC is used. If @ref MPACK_MALLOC is
+ * set and @ref MPACK_REALLOC is not, @ref MPACK_MALLOC is used with a simple copy
+ * to grow buffers.
+ */
+#if defined(MPACK_STDLIB) && MPACK_STDLIB && !defined(MPACK_MALLOC)
+#define MPACK_MALLOC malloc
+#define MPACK_REALLOC realloc
+#define MPACK_FREE free
+#endif
+
+/**
+ * @}
+ */
+
+
+/**
+ * @name Debugging Options
+ */
+
+/**
+ * @def MPACK_DEBUG
+ *
+ * Enables debug features. You may want to wrap this around your
+ * own debug preprocs. By default, this is enabled if @c DEBUG or @c _DEBUG
+ * are defined. (@c NDEBUG is not used since it is allowed to have
+ * different values in different translation units.)
+ */
+#if !defined(MPACK_DEBUG) && (defined(DEBUG) || defined(_DEBUG))
+#define MPACK_DEBUG 1
+#endif
+
+/**
+ * @def MPACK_STRINGS
+ *
+ * Enables descriptive error and type strings.
+ *
+ * This can be turned off (by defining it to 0) to maximize space savings
+ * on embedded devices. If this is disabled, string functions such as
+ * mpack_error_to_string() and mpack_type_to_string() return an empty string.
+ */
+#ifndef MPACK_STRINGS
+#define MPACK_STRINGS 1
+#endif
+
+/**
+ * Set this to 1 to implement a custom @ref mpack_assert_fail() function.
+ * See the documentation on @ref mpack_assert_fail() for details.
+ *
+ * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be
+ * triggered by bugs in MPack or bugs due to incorrect usage of MPack.
+ */
+#ifndef MPACK_CUSTOM_ASSERT
+#define MPACK_CUSTOM_ASSERT 0
+#endif
+
+/**
+ * @def MPACK_READ_TRACKING
+ *
+ * Enables compound type size tracking for readers. This ensures that the
+ * correct number of elements or bytes are read from a compound type.
+ *
+ * This is enabled by default in debug builds (provided a @c malloc() is
+ * available.)
+ */
+#if !defined(MPACK_READ_TRACKING) && \
+        defined(MPACK_DEBUG) && MPACK_DEBUG && \
+        defined(MPACK_READER) && MPACK_READER && \
+        defined(MPACK_MALLOC)
+#define MPACK_READ_TRACKING 1
+#endif
+
+/**
+ * @def MPACK_WRITE_TRACKING
+ *
+ * Enables compound type size tracking for writers. This ensures that the
+ * correct number of elements or bytes are written in a compound type.
+ *
+ * Note that without write tracking enabled, it is possible for buggy code
+ * to emit invalid MessagePack without flagging an error by writing the wrong
+ * number of elements or bytes in a compound type. With tracking enabled,
+ * MPack will catch such errors and break on the offending line of code.
+ *
+ * This is enabled by default in debug builds (provided a @c malloc() is
+ * available.)
+ */
+#if !defined(MPACK_WRITE_TRACKING) && \
+        defined(MPACK_DEBUG) && MPACK_DEBUG && \
+        defined(MPACK_WRITER) && MPACK_WRITER && \
+        defined(MPACK_MALLOC)
+#define MPACK_WRITE_TRACKING 1
+#endif
+
+/**
+ * @}
+ */
+
+
+/**
+ * @name Miscellaneous Options
+ * @{
+ */
+
+/**
+ * Whether to optimize for size or speed.
+ *
+ * Optimizing for size simplifies some parsing and encoding algorithms
+ * at the expense of speed, and saves a few kilobytes of space in the
+ * resulting executable.
+ *
+ * This automatically detects -Os with GCC/Clang. Unfortunately there
+ * doesn't seem to be a macro defined for /Os under MSVC.
+ */
+#ifndef MPACK_OPTIMIZE_FOR_SIZE
+#ifdef __OPTIMIZE_SIZE__
+#define MPACK_OPTIMIZE_FOR_SIZE 1
+#else
+#define MPACK_OPTIMIZE_FOR_SIZE 0
+#endif
+#endif
+
+/**
+ * Stack space in bytes to use when initializing a reader or writer
+ * with a stack-allocated buffer.
+ */
+#ifndef MPACK_STACK_SIZE
+#define MPACK_STACK_SIZE 4096
+#endif
+
+/**
+ * Buffer size to use for allocated buffers (such as for a file writer.)
+ *
+ * Starting with a single page and growing as needed seems to
+ * provide the best performance with minimal memory waste.
+ * Increasing this does not improve performance even when writing
+ * huge messages.
+ */
+#ifndef MPACK_BUFFER_SIZE
+#define MPACK_BUFFER_SIZE 4096
+#endif
+
+/**
+ * Minimum size of an allocated node page in bytes.
+ *
+ * The children for a given compound element must be contiguous, so
+ * larger pages than this may be allocated as needed. (Safety checks
+ * exist to prevent malicious data from causing too large allocations.)
+ *
+ * See @ref mpack_node_data_t for the size of nodes.
+ *
+ * Using as many nodes fit in one memory page seems to provide the
+ * best performance, and has very little waste when parsing small
+ * messages.
+ */
+#ifndef MPACK_NODE_PAGE_SIZE
+#define MPACK_NODE_PAGE_SIZE 4096
+#endif
+
+/**
+ * The initial depth for the node parser. When MPACK_MALLOC is available,
+ * the node parser has no practical depth limit, and it is not recursive
+ * so there is no risk of overflowing the call stack.
+ */
+#ifndef MPACK_NODE_INITIAL_DEPTH
+#define MPACK_NODE_INITIAL_DEPTH 8
+#endif
+
+/**
+ * The maximum depth for the node parser if @ref MPACK_MALLOC is not available.
+ */
+#ifndef MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC
+#define MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC 32
+#endif
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+
+/* mpack/mpack-platform.h.h */
+
+/**
+ * @file
+ *
+ * Abstracts all platform-specific code from MPack. This contains
+ * implementations of standard C functions when libc is not available,
+ * as well as wrappers to library functions.
+ */
+
+#ifndef MPACK_PLATFORM_H
+#define MPACK_PLATFORM_H 1
+
+
+
+/* Pre-include checks */
+
+#if defined(_MSC_VER) && _MSC_VER < 1800 && !defined(__cplusplus)
+#error "In Visual Studio 2012 and earlier, MPack must be compiled as C++. Enable the /Tp compiler flag."
+#endif
+
+#if defined(WIN32) && defined(MPACK_INTERNAL) && MPACK_INTERNAL
+#define _CRT_SECURE_NO_WARNINGS 1
+#endif
+
+
+
+/* Doxygen preprocs */
+#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN
+#define MPACK_HAS_CONFIG 0
+// We give these their default values of 0 here even though they are defined to
+// 1 in the doxyfile. Doxygen will show this as the value in the docs, even
+// though it ignores it when parsing the rest of the source. This is what we
+// want, since we want the documentation to show these defaults but still
+// generate documentation for the functions they add when they're on.
+#define MPACK_COMPATIBILITY 0
+#define MPACK_EXTENSIONS 0
+#endif
+
+
+
+/* Include the custom config file if enabled */
+
+#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG
+/* #include "mpack-config.h" */
+#endif
+
+/*
+ * Now that the optional config is included, we define the defaults
+ * for any of the configuration options and other switches that aren't
+ * yet defined.
+ */
+#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN
+/* #include "mpack-defaults-doxygen.h" */
+#else
+/* #include "mpack-defaults.h" */
+#endif
+
+/*
+ * All remaining configuration options that have not yet been set must
+ * be defined here in order to support -Wundef.
+ */
+#ifndef MPACK_DEBUG
+#define MPACK_DEBUG 0
+#endif
+#ifndef MPACK_CUSTOM_BREAK
+#define MPACK_CUSTOM_BREAK 0
+#endif
+#ifndef MPACK_READ_TRACKING
+#define MPACK_READ_TRACKING 0
+#endif
+#ifndef MPACK_WRITE_TRACKING
+#define MPACK_WRITE_TRACKING 0
+#endif
+#ifndef MPACK_EMIT_INLINE_DEFS
+#define MPACK_EMIT_INLINE_DEFS 0
+#endif
+#ifndef MPACK_AMALGAMATED
+#define MPACK_AMALGAMATED 0
+#endif
+#ifndef MPACK_RELEASE_VERSION
+#define MPACK_RELEASE_VERSION 0
+#endif
+#ifndef MPACK_INTERNAL
+#define MPACK_INTERNAL 0
+#endif
+#ifndef MPACK_NO_BUILTINS
+#define MPACK_NO_BUILTINS 0
+#endif
+
+
+
+/* System headers (based on configuration) */
+
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS 1
+#endif
+#ifndef __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS 1
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include <limits.h>
+
+#if MPACK_STDLIB
+#include <string.h>
+#include <stdlib.h>
+#endif
+
+#if MPACK_STDIO
+#include <stdio.h>
+#include <errno.h>
+#endif
+
+
+
+/*
+ * Header configuration
+ */
+
+#ifdef __cplusplus
+    #define MPACK_EXTERN_C_START extern "C" {
+    #define MPACK_EXTERN_C_END   }
+#else
+    #define MPACK_EXTERN_C_START /* nothing */
+    #define MPACK_EXTERN_C_END   /* nothing */
+#endif
+
+/* We can't push/pop diagnostics before GCC 4.6, so if you're on a really old
+ * compiler, MPack does not support the below warning flags. You will have to
+ * manually disable them to use MPack. */
+
+/* GCC versions before 5.1 warn about defining a C99 non-static inline function
+ * before declaring it (see issue #20). Diagnostic push is not supported before
+ * GCC 4.6. */
+#if defined(__GNUC__) && !defined(__clang__)
+    #if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || (__GNUC__ == 5 && __GNUC_MINOR__ < 1)
+        #ifdef __cplusplus
+            #define MPACK_DECLARED_INLINE_WARNING_START \
+                _Pragma ("GCC diagnostic push") \
+                _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"")
+        #else
+            #define MPACK_DECLARED_INLINE_WARNING_START \
+                _Pragma ("GCC diagnostic push") \
+                _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"")
+        #endif
+        #define MPACK_DECLARED_INLINE_WARNING_END \
+            _Pragma ("GCC diagnostic pop")
+    #endif
+#endif
+#ifndef MPACK_DECLARED_INLINE_WARNING_START
+    #define MPACK_DECLARED_INLINE_WARNING_START /* nothing */
+    #define MPACK_DECLARED_INLINE_WARNING_END /* nothing */
+#endif
+
+/* GCC versions before 4.8 warn about shadowing a function with a variable that
+ * isn't a function or function pointer (like "index"). Diagnostic push is not
+ * supported before GCC 4.6. */
+#if defined(__GNUC__) && !defined(__clang__)
+    #if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && __GNUC_MINOR__ < 8
+        #define MPACK_WSHADOW_WARNING_START \
+            _Pragma ("GCC diagnostic push") \
+            _Pragma ("GCC diagnostic ignored \"-Wshadow\"")
+        #define MPACK_WSHADOW_WARNING_END \
+            _Pragma ("GCC diagnostic pop")
+    #endif
+#endif
+#ifndef MPACK_WSHADOW_WARNING_START
+    #define MPACK_WSHADOW_WARNING_START /* nothing */
+    #define MPACK_WSHADOW_WARNING_END /* nothing */
+#endif
+
+#define MPACK_HEADER_START \
+    MPACK_WSHADOW_WARNING_START \
+    MPACK_DECLARED_INLINE_WARNING_START
+
+#define MPACK_HEADER_END \
+    MPACK_DECLARED_INLINE_WARNING_END \
+    MPACK_WSHADOW_WARNING_END
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+
+
+/* Miscellaneous helper macros */
+
+#define MPACK_UNUSED(var) ((void)(var))
+
+#define MPACK_STRINGIFY_IMPL(arg) #arg
+#define MPACK_STRINGIFY(arg) MPACK_STRINGIFY_IMPL(arg)
+
+// This is a workaround for MSVC's incorrect expansion of __VA_ARGS__. It
+// treats __VA_ARGS__ as a single preprocessor token when passed in the
+// argument list of another macro unless we use an outer wrapper to expand it
+// lexically first. (For safety/consistency we use this in all variadic macros
+// that don't ignore the variadic arguments regardless of whether __VA_ARGS__
+// is passed to another macro.)
+//     https://stackoverflow.com/a/32400131
+#define MPACK_EXPAND(x) x
+
+// Extracts the first argument of a variadic macro list, where there might only
+// be one argument.
+#define MPACK_EXTRACT_ARG0_IMPL(first, ...) first
+#define MPACK_EXTRACT_ARG0(...) MPACK_EXPAND(MPACK_EXTRACT_ARG0_IMPL( __VA_ARGS__ , ignored))
+
+// Stringifies the first argument of a variadic macro list, where there might
+// only be one argument.
+#define MPACK_STRINGIFY_ARG0_impl(first, ...) #first
+#define MPACK_STRINGIFY_ARG0(...) MPACK_EXPAND(MPACK_STRINGIFY_ARG0_impl( __VA_ARGS__ , ignored))
+
+
+
+/*
+ * Definition of inline macros.
+ *
+ * MPack does not use static inline in header files; only one non-inline definition
+ * of each function should exist in the final build. This can reduce the binary size
+ * in cases where the compiler cannot or chooses not to inline a function.
+ * The addresses of functions should also compare equal across translation units
+ * regardless of whether they are declared inline.
+ *
+ * The above requirements mean that the declaration and definition of non-trivial
+ * inline functions must be separated so that the definitions will only
+ * appear when necessary. In addition, three different linkage models need
+ * to be supported:
+ *
+ *  - The C99 model, where a standalone function is emitted only if there is any
+ *    `extern inline` or non-`inline` declaration (including the definition itself)
+ *
+ *  - The GNU model, where an `inline` definition emits a standalone function and an
+ *    `extern inline` definition does not, regardless of other declarations
+ *
+ *  - The C++ model, where `inline` emits a standalone function with special
+ *    (COMDAT) linkage
+ *
+ * The macros below wrap up everything above. All inline functions defined in header
+ * files have a single non-inline definition emitted in the compilation of
+ * mpack-platform.c. All inline declarations and definitions use the same MPACK_INLINE
+ * specification to simplify the rules on when standalone functions are emitted.
+ * Inline functions in source files are defined MPACK_STATIC_INLINE.
+ *
+ * Additional reading:
+ *     http://www.greenend.org.uk/rjk/tech/inline.html
+ */
+
+#if defined(__cplusplus)
+    // C++ rules
+    // The linker will need COMDAT support to link C++ object files,
+    // so we don't need to worry about emitting definitions from C++
+    // translation units. If mpack-platform.c (or the amalgamation)
+    // is compiled as C, its definition will be used, otherwise a
+    // C++ definition will be used, and no other C files will emit
+    // a definition.
+    #define MPACK_INLINE inline
+
+#elif defined(_MSC_VER)
+    // MSVC 2013 always uses COMDAT linkage, but it doesn't treat 'inline' as a
+    // keyword in C99 mode. (This appears to be fixed in a later version of
+    // MSVC but we don't bother detecting it.)
+    #define MPACK_INLINE __inline
+    #define MPACK_STATIC_INLINE static __inline
+
+#elif defined(__GNUC__) && (defined(__GNUC_GNU_INLINE__) || \
+        (!defined(__GNUC_STDC_INLINE__) && !defined(__GNUC_GNU_INLINE__)))
+    // GNU rules
+    #if MPACK_EMIT_INLINE_DEFS
+        #define MPACK_INLINE inline
+    #else
+        #define MPACK_INLINE extern inline
+    #endif
+
+#elif defined(__TINYC__)
+    // tcc ignores the inline keyword, so we have to use static inline. We
+    // issue a warning to make sure you are aware. You can define the below
+    // macro to disable the warning. Hopefully this will be fixed soon:
+    //     https://lists.nongnu.org/archive/html/tinycc-devel/2019-06/msg00000.html
+    #ifndef MPACK_DISABLE_TINYC_INLINE_WARNING
+        #warning "Single-definition inline is not supported by tcc. All inlines will be static. Define MPACK_DISABLE_TINYC_INLINE_WARNING to disable this warning."
+    #endif
+    #define MPACK_INLINE static inline
+
+#else
+    // C99 rules
+    #if MPACK_EMIT_INLINE_DEFS
+        #define MPACK_INLINE extern inline
+    #else
+        #define MPACK_INLINE inline
+    #endif
+#endif
+
+#ifndef MPACK_STATIC_INLINE
+#define MPACK_STATIC_INLINE static inline
+#endif
+
+#ifdef MPACK_OPTIMIZE_FOR_SPEED
+    #error "You should define MPACK_OPTIMIZE_FOR_SIZE, not MPACK_OPTIMIZE_FOR_SPEED."
+#endif
+
+
+
+/*
+ * Prevent inlining
+ *
+ * When a function is only used once, it is almost always inlined
+ * automatically. This can cause poor instruction cache usage because a
+ * function that should rarely be called (such as buffer exhaustion handling)
+ * will get inlined into the middle of a hot code path.
+ */
+
+#if !MPACK_NO_BUILTINS
+    #if defined(_MSC_VER)
+        #define MPACK_NOINLINE __declspec(noinline)
+    #elif defined(__GNUC__) || defined(__clang__)
+        #define MPACK_NOINLINE __attribute__((noinline))
+    #endif
+#endif
+#ifndef MPACK_NOINLINE
+    #define MPACK_NOINLINE /* nothing */
+#endif
+
+
+
+/* Some compiler-specific keywords and builtins */
+
+#if !MPACK_NO_BUILTINS
+    #if defined(__GNUC__) || defined(__clang__)
+        #define MPACK_UNREACHABLE __builtin_unreachable()
+        #define MPACK_NORETURN(fn) fn __attribute__((noreturn))
+        #define MPACK_RESTRICT __restrict__
+    #elif defined(_MSC_VER)
+        #define MPACK_UNREACHABLE __assume(0)
+        #define MPACK_NORETURN(fn) __declspec(noreturn) fn
+        #define MPACK_RESTRICT __restrict
+    #endif
+#endif
+
+#ifndef MPACK_RESTRICT
+#ifdef __cplusplus
+#define MPACK_RESTRICT /* nothing, unavailable in C++ */
+#else
+#define MPACK_RESTRICT restrict /* required in C99 */
+#endif
+#endif
+
+#ifndef MPACK_UNREACHABLE
+#define MPACK_UNREACHABLE ((void)0)
+#endif
+#ifndef MPACK_NORETURN
+#define MPACK_NORETURN(fn) fn
+#endif
+
+
+
+/*
+ * Likely/unlikely
+ *
+ * These should only really be used when a branch is taken (or not taken) less
+ * than 1/1000th of the time. Buffer flush checks when writing very small
+ * elements are a good example.
+ */
+
+#if !MPACK_NO_BUILTINS
+    #if defined(__GNUC__) || defined(__clang__)
+        #ifndef MPACK_LIKELY
+            #define MPACK_LIKELY(x) __builtin_expect((x),1)
+        #endif
+        #ifndef MPACK_UNLIKELY
+            #define MPACK_UNLIKELY(x) __builtin_expect((x),0)
+        #endif
+    #endif
+#endif
+
+#ifndef MPACK_LIKELY
+    #define MPACK_LIKELY(x) (x)
+#endif
+#ifndef MPACK_UNLIKELY
+    #define MPACK_UNLIKELY(x) (x)
+#endif
+
+
+
+/* Static assert */
+
+#ifndef MPACK_STATIC_ASSERT
+    #if defined(__cplusplus)
+        #if __cplusplus >= 201103L
+            #define MPACK_STATIC_ASSERT static_assert
+        #endif
+    #elif defined(__STDC_VERSION__)
+        #if __STDC_VERSION__ >= 201112L
+            #define MPACK_STATIC_ASSERT _Static_assert
+        #endif
+    #endif
+#endif
+
+#if !MPACK_NO_BUILTINS
+    #ifndef MPACK_STATIC_ASSERT
+        #if defined(__has_feature)
+            #if __has_feature(cxx_static_assert)
+                #define MPACK_STATIC_ASSERT static_assert
+            #elif __has_feature(c_static_assert)
+                #define MPACK_STATIC_ASSERT _Static_assert
+            #endif
+        #endif
+    #endif
+
+    #ifndef MPACK_STATIC_ASSERT
+        #if defined(__GNUC__)
+            /* Diagnostic push is not supported before GCC 4.6. */
+            #if defined(__clang__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+                #ifndef __cplusplus
+                    #if defined(__clang__) || __GNUC__ >= 5
+                    #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-Wpedantic\""
+                    #else
+                    #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-pedantic\""
+                    #endif
+                    #define MPACK_STATIC_ASSERT(expr, str) do { \
+                        _Pragma ("GCC diagnostic push") \
+                        _Pragma (MPACK_IGNORE_PEDANTIC) \
+                        _Pragma ("GCC diagnostic ignored \"-Wc++-compat\"") \
+                        _Static_assert(expr, str); \
+                        _Pragma ("GCC diagnostic pop") \
+                    } while (0)
+                #endif
+            #endif
+        #endif
+    #endif
+
+    #ifndef MPACK_STATIC_ASSERT
+        #ifdef _MSC_VER
+            #if _MSC_VER >= 1600
+                #define MPACK_STATIC_ASSERT static_assert
+            #endif
+        #endif
+    #endif
+#endif
+
+#ifndef MPACK_STATIC_ASSERT
+    #define MPACK_STATIC_ASSERT(expr, str) (MPACK_UNUSED(sizeof(char[1 - 2*!(expr)])))
+#endif
+
+
+
+/* _Generic */
+
+#ifndef MPACK_HAS_GENERIC
+    #if defined(__clang__) && defined(__has_feature)
+        // With Clang we can test for _Generic support directly
+        // and ignore C/C++ version
+        #if __has_feature(c_generic_selections)
+            #define MPACK_HAS_GENERIC 1
+        #else
+            #define MPACK_HAS_GENERIC 0
+        #endif
+    #endif
+#endif
+
+#ifndef MPACK_HAS_GENERIC
+    #if defined(__STDC_VERSION__)
+        #if __STDC_VERSION__ >= 201112L
+            #if defined(__GNUC__) && !defined(__clang__)
+                // GCC does not have full C11 support in GCC 4.7 and 4.8
+                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
+                    #define MPACK_HAS_GENERIC 1
+                #endif
+            #else
+                // We hope other compilers aren't lying about C11/_Generic support
+                #define MPACK_HAS_GENERIC 1
+            #endif
+        #endif
+    #endif
+#endif
+
+#ifndef MPACK_HAS_GENERIC
+    #define MPACK_HAS_GENERIC 0
+#endif
+
+
+
+/*
+ * Finite Math
+ *
+ * -ffinite-math-only, included in -ffast-math, breaks functions that
+ * that check for non-finite real values such as isnan() and isinf().
+ *
+ * We should use this to trap errors when reading data that contains
+ * non-finite reals. This isn't currently implemented.
+ */
+
+#ifndef MPACK_FINITE_MATH
+#if defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__
+#define MPACK_FINITE_MATH 1
+#endif
+#endif
+
+#ifndef MPACK_FINITE_MATH
+#define MPACK_FINITE_MATH 0
+#endif
+
+
+
+/*
+ * Endianness checks
+ *
+ * These define MPACK_NHSWAP*() which swap network<->host byte
+ * order when needed.
+ *
+ * We leave them undefined if we can't determine the endianness
+ * at compile-time, in which case we fall back to bit-shifts.
+ *
+ * See the notes in mpack-common.h.
+ */
+
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__)
+    #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+        #define MPACK_NHSWAP16(x) (x)
+        #define MPACK_NHSWAP32(x) (x)
+        #define MPACK_NHSWAP64(x) (x)
+    #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+        #if !MPACK_NO_BUILTINS
+            #if defined(__clang__)
+                #ifdef __has_builtin
+                    // Unlike the GCC builtins, the bswap builtins in Clang
+                    // significantly improve ARM performance.
+                    #if __has_builtin(__builtin_bswap16)
+                        #define MPACK_NHSWAP16(x) __builtin_bswap16(x)
+                    #endif
+                    #if __has_builtin(__builtin_bswap32)
+                        #define MPACK_NHSWAP32(x) __builtin_bswap32(x)
+                    #endif
+                    #if __has_builtin(__builtin_bswap64)
+                        #define MPACK_NHSWAP64(x) __builtin_bswap64(x)
+                    #endif
+                #endif
+
+            #elif defined(__GNUC__)
+
+                // The GCC bswap builtins are apparently poorly optimized on older
+                // versions of GCC, so we set a minimum version here just in case.
+                //     http://hardwarebug.org/2010/01/14/beware-the-builtins/
+
+                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+                    #define MPACK_NHSWAP64(x) __builtin_bswap64(x)
+                #endif
+
+                // __builtin_bswap16() was not implemented on all platforms
+                // until GCC 4.8.0:
+                //     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624
+                //
+                // The 16- and 32-bit versions in GCC significantly reduce performance
+                // on ARM with little effect on code size so we don't use them.
+
+            #endif
+        #endif
+    #endif
+
+#elif defined(_MSC_VER) && defined(_WIN32) && !MPACK_NO_BUILTINS
+
+    // On Windows, we assume x86 and x86_64 are always little-endian.
+    // We make no assumptions about ARM even though all current
+    // Windows Phone devices are little-endian in case Microsoft's
+    // compiler is ever used with a big-endian ARM device.
+
+    #if defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)
+        #define MPACK_NHSWAP16(x) _byteswap_ushort(x)
+        #define MPACK_NHSWAP32(x) _byteswap_ulong(x)
+        #define MPACK_NHSWAP64(x) _byteswap_uint64(x)
+    #endif
+
+#endif
+
+#if defined(__FLOAT_WORD_ORDER__) && defined(__BYTE_ORDER__)
+
+    // We check where possible that the float byte order matches the
+    // integer byte order. This is extremely unlikely to fail, but
+    // we check anyway just in case.
+    //
+    // (The static assert is placed in float/double encoders instead
+    // of here because our static assert fallback doesn't work at
+    // file scope)
+
+    #define MPACK_CHECK_FLOAT_ORDER() \
+        MPACK_STATIC_ASSERT(__FLOAT_WORD_ORDER__ == __BYTE_ORDER__, \
+            "float byte order does not match int byte order! float/double " \
+            "encoding is not properly implemented on this platform.")
+
+#endif
+
+#ifndef MPACK_CHECK_FLOAT_ORDER
+    #define MPACK_CHECK_FLOAT_ORDER() /* nothing */
+#endif
+
+
+/*
+ * Here we define mpack_assert() and mpack_break(). They both work like a normal
+ * assertion function in debug mode, causing a trap or abort. However, on some platforms
+ * you can safely resume execution from mpack_break(), whereas mpack_assert() is
+ * always fatal.
+ *
+ * In release mode, mpack_assert() is converted to an assurance to the compiler
+ * that the expression cannot be false (via e.g. __assume() or __builtin_unreachable())
+ * to improve optimization where supported. There is thus no point in "safely" handling
+ * the case of this being false. Writing mpack_assert(0) rarely makes sense (except
+ * possibly as a default handler in a switch) since the compiler will throw away any
+ * code after it. If at any time an mpack_assert() is not true, the behaviour is
+ * undefined. This also means the expression is evaluated even in release.
+ *
+ * mpack_break() on the other hand is compiled to nothing in release. It is
+ * used in situations where we want to highlight a programming error as early as
+ * possible (in the debugger), but we still handle the situation safely if it
+ * happens in release to avoid producing incorrect results (such as in
+ * MPACK_WRITE_TRACKING.) It does not take an expression to test because it
+ * belongs in a safe-handling block after its failing condition has been tested.
+ *
+ * If stdio is available, we can add a format string describing the error, and
+ * on some compilers we can declare it noreturn to get correct results from static
+ * analysis tools. Note that the format string and arguments are not evaluated unless
+ * the assertion is hit.
+ *
+ * Note that any arguments to mpack_assert() beyond the first are only evaluated
+ * if the expression is false (and are never evaluated in release.)
+ *
+ * mpack_assert_fail() and mpack_break_hit() are defined separately
+ * because assert is noreturn and break isn't. This distinction is very
+ * important for static analysis tools to give correct results.
+ */
+
+#if MPACK_DEBUG
+
+    /**
+     * @addtogroup config
+     * @{
+     */
+    /**
+     * @name Debug Functions
+     */
+    /**
+     * Implement this and define @ref MPACK_CUSTOM_ASSERT to use a custom
+     * assertion function.
+     *
+     * This function should not return. If it does, MPack will @c abort().
+     *
+     * If you use C++, make sure you include @c mpack.h where you define
+     * this to get the correct linkage (or define it <code>extern "C"</code>.)
+     *
+     * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be
+     * triggered by bugs in MPack or bugs due to incorrect usage of MPack.
+     */
+    void mpack_assert_fail(const char* message);
+    /**
+     * @}
+     */
+    /**
+     * @}
+     */
+
+    MPACK_NORETURN(void mpack_assert_fail_wrapper(const char* message));
+    #if MPACK_STDIO
+        MPACK_NORETURN(void mpack_assert_fail_format(const char* format, ...));
+        #define mpack_assert_fail_at(line, file, exprstr, format, ...) \
+                MPACK_EXPAND(mpack_assert_fail_format("mpack assertion failed at " file ":" #line "\n%s\n" format, exprstr, __VA_ARGS__))
+    #else
+        #define mpack_assert_fail_at(line, file, exprstr, format, ...) \
+                mpack_assert_fail_wrapper("mpack assertion failed at " file ":" #line "\n" exprstr "\n")
+    #endif
+
+    #define mpack_assert_fail_pos(line, file, exprstr, expr, ...) \
+            MPACK_EXPAND(mpack_assert_fail_at(line, file, exprstr, __VA_ARGS__))
+
+    // This contains a workaround to the pedantic C99 requirement of having at
+    // least one argument to a variadic macro. The first argument is the
+    // boolean expression, the optional second argument (if provided) must be a
+    // literal format string, and any additional arguments are the format
+    // argument list.
+    //
+    // Unfortunately this means macros are expanded in the expression before it
+    // gets stringified. I haven't found a workaround to this.
+    //
+    // This adds two unused arguments to the format argument list when a
+    // format string is provided, so this would complicate the use of
+    // -Wformat and __attribute__((format)) on mpack_assert_fail_format() if we
+    // ever bothered to implement it.
+    #define mpack_assert(...) \
+            MPACK_EXPAND(((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \
+                mpack_assert_fail_pos(__LINE__, __FILE__, MPACK_STRINGIFY_ARG0(__VA_ARGS__) , __VA_ARGS__ , "", NULL) : \
+                (void)0))
+
+    void mpack_break_hit(const char* message);
+    #if MPACK_STDIO
+        void mpack_break_hit_format(const char* format, ...);
+        #define mpack_break_hit_at(line, file, ...) \
+                MPACK_EXPAND(mpack_break_hit_format("mpack breakpoint hit at " file ":" #line "\n" __VA_ARGS__))
+    #else
+        #define mpack_break_hit_at(line, file, ...) \
+                mpack_break_hit("mpack breakpoint hit at " file ":" #line )
+    #endif
+    #define mpack_break_hit_pos(line, file, ...) MPACK_EXPAND(mpack_break_hit_at(line, file, __VA_ARGS__))
+    #define mpack_break(...) MPACK_EXPAND(mpack_break_hit_pos(__LINE__, __FILE__, __VA_ARGS__))
+#else
+    #define mpack_assert(...) \
+            (MPACK_EXPAND((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \
+                (MPACK_UNREACHABLE, (void)0) : \
+                (void)0))
+    #define mpack_break(...) ((void)0)
+#endif
+
+
+
+/* Wrap some needed libc functions */
+
+#if MPACK_STDLIB
+    #define mpack_memcmp memcmp
+    #define mpack_memcpy memcpy
+    #define mpack_memmove memmove
+    #define mpack_memset memset
+    #ifndef mpack_strlen
+        #define mpack_strlen strlen
+    #endif
+
+    #if defined(MPACK_UNIT_TESTS) && MPACK_INTERNAL && defined(__GNUC__)
+        // make sure we don't use the stdlib directly during development
+        #undef memcmp
+        #undef memcpy
+        #undef memmove
+        #undef memset
+        #undef strlen
+        #undef malloc
+        #undef free
+        #pragma GCC poison memcmp
+        #pragma GCC poison memcpy
+        #pragma GCC poison memmove
+        #pragma GCC poison memset
+        #pragma GCC poison strlen
+        #pragma GCC poison malloc
+        #pragma GCC poison free
+    #endif
+
+#elif defined(__GNUC__) && !MPACK_NO_BUILTINS
+    // there's not always a builtin memmove for GCC,
+    // and we don't have a way to test for it
+    #define mpack_memcmp __builtin_memcmp
+    #define mpack_memcpy __builtin_memcpy
+    #define mpack_memset __builtin_memset
+    #define mpack_strlen __builtin_strlen
+
+#elif defined(__clang__) && defined(__has_builtin) && !MPACK_NO_BUILTINS
+    #if __has_builtin(__builtin_memcmp)
+    #define mpack_memcmp __builtin_memcmp
+    #endif
+    #if __has_builtin(__builtin_memcpy)
+    #define mpack_memcpy __builtin_memcpy
+    #endif
+    #if __has_builtin(__builtin_memmove)
+    #define mpack_memmove __builtin_memmove
+    #endif
+    #if __has_builtin(__builtin_memset)
+    #define mpack_memset __builtin_memset
+    #endif
+    #if __has_builtin(__builtin_strlen)
+    #define mpack_strlen __builtin_strlen
+    #endif
+#endif
+
+#ifndef mpack_memcmp
+int mpack_memcmp(const void* s1, const void* s2, size_t n);
+#endif
+#ifndef mpack_memcpy
+void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n);
+#endif
+#ifndef mpack_memmove
+void* mpack_memmove(void* s1, const void* s2, size_t n);
+#endif
+#ifndef mpack_memset
+void* mpack_memset(void* s, int c, size_t n);
+#endif
+#ifndef mpack_strlen
+size_t mpack_strlen(const char* s);
+#endif
+
+#if MPACK_STDIO
+    #if defined(WIN32)
+        #define mpack_snprintf _snprintf
+    #else
+        #define mpack_snprintf snprintf
+    #endif
+#endif
+
+
+
+/* Debug logging */
+#if 0
+    #include <stdio.h>
+    #define mpack_log(...) (MPACK_EXPAND(printf(__VA_ARGS__)), fflush(stdout))
+#else
+    #define mpack_log(...) ((void)0)
+#endif
+
+
+
+/* Make sure our configuration makes sense */
+#if defined(MPACK_MALLOC) && !defined(MPACK_FREE)
+    #error "MPACK_MALLOC requires MPACK_FREE."
+#endif
+#if !defined(MPACK_MALLOC) && defined(MPACK_FREE)
+    #error "MPACK_FREE requires MPACK_MALLOC."
+#endif
+#if MPACK_READ_TRACKING && !defined(MPACK_READER)
+    #error "MPACK_READ_TRACKING requires MPACK_READER."
+#endif
+#if MPACK_WRITE_TRACKING && !defined(MPACK_WRITER)
+    #error "MPACK_WRITE_TRACKING requires MPACK_WRITER."
+#endif
+#ifndef MPACK_MALLOC
+    #if MPACK_STDIO
+        #error "MPACK_STDIO requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
+    #endif
+    #if MPACK_READ_TRACKING
+        #error "MPACK_READ_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
+    #endif
+    #if MPACK_WRITE_TRACKING
+        #error "MPACK_WRITE_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
+    #endif
+#endif
+
+
+
+/* Implement realloc if unavailable */
+#ifdef MPACK_MALLOC
+    #ifdef MPACK_REALLOC
+        MPACK_INLINE void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) {
+            MPACK_UNUSED(used_size);
+            return MPACK_REALLOC(old_ptr, new_size);
+        }
+    #else
+        void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size);
+    #endif
+#endif
+
+
+
+/**
+ * @}
+ */
+
+MPACK_EXTERN_C_END
+MPACK_HEADER_END
+
+#endif
+
+
+/* mpack/mpack-common.h.h */
+
+/**
+ * @file
+ *
+ * Defines types and functions shared by the MPack reader and writer.
+ */
+
+#ifndef MPACK_COMMON_H
+#define MPACK_COMMON_H 1
+
+/* #include "mpack-platform.h" */
+
+#ifndef MPACK_PRINT_BYTE_COUNT
+#define MPACK_PRINT_BYTE_COUNT 12
+#endif
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+
+
+/**
+ * @defgroup common Tags and Common Elements
+ *
+ * Contains types, constants and functions shared by both the encoding
+ * and decoding portions of MPack.
+ *
+ * @{
+ */
+
+/* Version information */
+
+#define MPACK_VERSION_MAJOR 1  /**< The major version number of MPack. */
+#define MPACK_VERSION_MINOR 0  /**< The minor version number of MPack. */
+#define MPACK_VERSION_PATCH 0  /**< The patch version number of MPack. */
+
+/** A number containing the version number of MPack for comparison purposes. */
+#define MPACK_VERSION ((MPACK_VERSION_MAJOR * 10000) + \
+        (MPACK_VERSION_MINOR * 100) + MPACK_VERSION_PATCH)
+
+/** A macro to test for a minimum version of MPack. */
+#define MPACK_VERSION_AT_LEAST(major, minor, patch) \
+        (MPACK_VERSION >= (((major) * 10000) + ((minor) * 100) + (patch)))
+
+/** @cond */
+#if (MPACK_VERSION_PATCH > 0)
+#define MPACK_VERSION_STRING_BASE \
+        MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \
+        MPACK_STRINGIFY(MPACK_VERSION_MINOR) "." \
+        MPACK_STRINGIFY(MPACK_VERSION_PATCH)
+#else
+#define MPACK_VERSION_STRING_BASE \
+        MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \
+        MPACK_STRINGIFY(MPACK_VERSION_MINOR)
+#endif
+/** @endcond */
+
+/**
+ * @def MPACK_VERSION_STRING
+ * @hideinitializer
+ *
+ * A string containing the MPack version.
+ */
+#if MPACK_RELEASE_VERSION
+#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE
+#else
+#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE "dev"
+#endif
+
+/**
+ * @def MPACK_LIBRARY_STRING
+ * @hideinitializer
+ *
+ * A string describing MPack, containing the library name, version and debug mode.
+ */
+#if MPACK_DEBUG
+#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING "-debug"
+#else
+#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING
+#endif
+
+/** @cond */
+/**
+ * @def MPACK_MAXIMUM_TAG_SIZE
+ *
+ * The maximum encoded size of a tag in bytes.
+ */
+#define MPACK_MAXIMUM_TAG_SIZE 9
+/** @endcond */
+
+#if MPACK_EXTENSIONS
+/**
+ * @def MPACK_TIMESTAMP_NANOSECONDS_MAX
+ *
+ * The maximum value of nanoseconds for a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+#define MPACK_TIMESTAMP_NANOSECONDS_MAX 999999999
+#endif
+
+
+
+#if MPACK_COMPATIBILITY
+/**
+ * Versions of the MessagePack format.
+ *
+ * A reader, writer, or tree can be configured to serialize in an older
+ * version of the MessagePack spec. This is necessary to interface with
+ * older MessagePack libraries that do not support new MessagePack features.
+ *
+ * @note This requires @ref MPACK_COMPATIBILITY.
+ */
+typedef enum mpack_version_t {
+
+    /**
+     * Version 1.0/v4, supporting only the @c raw type without @c str8.
+     */
+    mpack_version_v4 = 4,
+
+    /**
+     * Version 2.0/v5, supporting the @c str8, @c bin and @c ext types.
+     */
+    mpack_version_v5 = 5,
+
+    /**
+     * The most recent supported version of MessagePack. This is the default.
+     */
+    mpack_version_current = mpack_version_v5,
+
+} mpack_version_t;
+#endif
+
+/**
+ * Error states for MPack objects.
+ *
+ * When a reader, writer, or tree is in an error state, all subsequent calls
+ * are ignored and their return values are nil/zero. You should check whether
+ * the source is in an error state before using such values.
+ */
+typedef enum mpack_error_t {
+    mpack_ok = 0,        /**< No error. */
+    mpack_error_io = 2,  /**< The reader or writer failed to fill or flush, or some other file or socket error occurred. */
+    mpack_error_invalid, /**< The data read is not valid MessagePack. */
+    mpack_error_unsupported, /**< The data read is not supported by this configuration of MPack. (See @ref MPACK_EXTENSIONS.) */
+    mpack_error_type,    /**< The type or value range did not match what was expected by the caller. */
+    mpack_error_too_big, /**< A read or write was bigger than the maximum size allowed for that operation. */
+    mpack_error_memory,  /**< An allocation failure occurred. */
+    mpack_error_bug,     /**< The MPack API was used incorrectly. (This will always assert in debug mode.) */
+    mpack_error_data,    /**< The contained data is not valid. */
+    mpack_error_eof,     /**< The reader failed to read because of file or socket EOF */
+} mpack_error_t;
+
+/**
+ * Converts an MPack error to a string. This function returns an empty
+ * string when MPACK_DEBUG is not set.
+ */
+const char* mpack_error_to_string(mpack_error_t error);
+
+/**
+ * Defines the type of a MessagePack tag.
+ *
+ * Note that extension types, both user defined and built-in, are represented
+ * in tags as @ref mpack_type_ext. The value for an extension type is stored
+ * separately.
+ */
+typedef enum mpack_type_t {
+    mpack_type_missing = 0, /**< Special type indicating a missing optional value. */
+    mpack_type_nil,         /**< A null value. */
+    mpack_type_bool,        /**< A boolean (true or false.) */
+    mpack_type_int,         /**< A 64-bit signed integer. */
+    mpack_type_uint,        /**< A 64-bit unsigned integer. */
+    mpack_type_float,       /**< A 32-bit IEEE 754 floating point number. */
+    mpack_type_double,      /**< A 64-bit IEEE 754 floating point number. */
+    mpack_type_str,         /**< A string. */
+    mpack_type_bin,         /**< A chunk of binary data. */
+    mpack_type_array,       /**< An array of MessagePack objects. */
+    mpack_type_map,         /**< An ordered map of key/value pairs of MessagePack objects. */
+
+    #if MPACK_EXTENSIONS
+    /**
+     * A typed MessagePack extension object containing a chunk of binary data.
+     *
+     * @note This requires @ref MPACK_EXTENSIONS.
+     */
+    mpack_type_ext,
+    #endif
+} mpack_type_t;
+
+/**
+ * Converts an MPack type to a string. This function returns an empty
+ * string when MPACK_DEBUG is not set.
+ */
+const char* mpack_type_to_string(mpack_type_t type);
+
+#if MPACK_EXTENSIONS
+/**
+ * A timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+typedef struct mpack_timestamp_t {
+    int64_t seconds; /*< The number of seconds (signed) since 1970-01-01T00:00:00Z. */
+    uint32_t nanoseconds; /*< The number of additional nanoseconds, between 0 and 999,999,999. */
+} mpack_timestamp_t;
+#endif
+
+/**
+ * An MPack tag is a MessagePack object header. It is a variant type
+ * representing any kind of object, and includes the length of compound types
+ * (e.g. map, array, string) or the value of non-compound types (e.g. boolean,
+ * integer, float.)
+ *
+ * If the type is compound (str, bin, ext, array or map), the contained
+ * elements or bytes are stored separately.
+ *
+ * This structure is opaque; its fields should not be accessed outside
+ * of MPack.
+ */
+typedef struct mpack_tag_t mpack_tag_t;
+
+/* Hide internals from documentation */
+/** @cond */
+struct mpack_tag_t {
+    mpack_type_t type; /*< The type of value. */
+
+    #if MPACK_EXTENSIONS
+    int8_t exttype; /*< The extension type if the type is @ref mpack_type_ext. */
+    #endif
+
+    /* The value for non-compound types. */
+    union {
+        uint64_t u; /*< The value if the type is unsigned int. */
+        int64_t  i; /*< The value if the type is signed int. */
+        double   d; /*< The value if the type is double. */
+        float    f; /*< The value if the type is float. */
+        bool     b; /*< The value if the type is bool. */
+
+        /* The number of bytes if the type is str, bin or ext. */
+        uint32_t l;
+
+        /* The element count if the type is an array, or the number of
+            key/value pairs if the type is map. */
+        uint32_t n;
+    } v;
+};
+/** @endcond */
+
+/**
+ * @name Tag Generators
+ * @{
+ */
+
+/**
+ * @def MPACK_TAG_ZERO
+ *
+ * An @ref mpack_tag_t initializer that zeroes the given tag.
+ *
+ * @warning This does not make the tag nil! The tag's type is invalid when
+ * initialized this way. Use @ref mpack_tag_make_nil() to generate a nil tag.
+ */
+#if MPACK_EXTENSIONS
+#define MPACK_TAG_ZERO {(mpack_type_t)0, 0, {0}}
+#else
+#define MPACK_TAG_ZERO {(mpack_type_t)0, {0}}
+#endif
+
+/** Generates a nil tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_nil(void) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_nil;
+    return ret;
+}
+
+/** Generates a bool tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_bool(bool value) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_bool;
+    ret.v.b = value;
+    return ret;
+}
+
+/** Generates a bool tag with value true. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_true(void) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_bool;
+    ret.v.b = true;
+    return ret;
+}
+
+/** Generates a bool tag with value false. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_false(void) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_bool;
+    ret.v.b = false;
+    return ret;
+}
+
+/** Generates a signed int tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_int(int64_t value) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_int;
+    ret.v.i = value;
+    return ret;
+}
+
+/** Generates an unsigned int tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_uint(uint64_t value) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_uint;
+    ret.v.u = value;
+    return ret;
+}
+
+/** Generates a float tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_float(float value) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_float;
+    ret.v.f = value;
+    return ret;
+}
+
+/** Generates a double tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_double(double value) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_double;
+    ret.v.d = value;
+    return ret;
+}
+
+/** Generates an array tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_array(uint32_t count) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_array;
+    ret.v.n = count;
+    return ret;
+}
+
+/** Generates a map tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_map(uint32_t count) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_map;
+    ret.v.n = count;
+    return ret;
+}
+
+/** Generates a str tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_str(uint32_t length) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_str;
+    ret.v.l = length;
+    return ret;
+}
+
+/** Generates a bin tag. */
+MPACK_INLINE mpack_tag_t mpack_tag_make_bin(uint32_t length) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_bin;
+    ret.v.l = length;
+    return ret;
+}
+
+#if MPACK_EXTENSIONS
+/**
+ * Generates an ext tag.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+MPACK_INLINE mpack_tag_t mpack_tag_make_ext(int8_t exttype, uint32_t length) {
+    mpack_tag_t ret = MPACK_TAG_ZERO;
+    ret.type = mpack_type_ext;
+    ret.exttype = exttype;
+    ret.v.l = length;
+    return ret;
+}
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Tag Querying Functions
+ * @{
+ */
+
+/**
+ * Gets the type of a tag.
+ */
+MPACK_INLINE mpack_type_t mpack_tag_type(mpack_tag_t* tag) {
+    return tag->type;
+}
+
+/**
+ * Gets the boolean value of a bool-type tag. The tag must be of type @ref
+ * mpack_type_bool.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_bool. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ */
+MPACK_INLINE bool mpack_tag_bool_value(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_bool, "tag is not a bool!");
+    return tag->v.b;
+}
+
+/**
+ * Gets the signed integer value of an int-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_int. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @warning This does not convert between signed and unsigned tags! A positive
+ * integer may be stored in a tag as either @ref mpack_type_int or @ref
+ * mpack_type_uint. You must check the type first; this can only be used if the
+ * type is @ref mpack_type_int.
+ *
+ * @see mpack_type_int
+ */
+MPACK_INLINE int64_t mpack_tag_int_value(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_int, "tag is not an int!");
+    return tag->v.i;
+}
+
+/**
+ * Gets the unsigned integer value of a uint-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_uint. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @warning This does not convert between signed and unsigned tags! A positive
+ * integer may be stored in a tag as either @ref mpack_type_int or @ref
+ * mpack_type_uint. You must check the type first; this can only be used if the
+ * type is @ref mpack_type_uint.
+ *
+ * @see mpack_type_uint
+ */
+MPACK_INLINE uint64_t mpack_tag_uint_value(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_uint, "tag is not a uint!");
+    return tag->v.u;
+}
+
+/**
+ * Gets the float value of a float-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_float. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @warning This does not convert between float and double tags! This can only
+ * be used if the type is @ref mpack_type_float.
+ *
+ * @see mpack_type_float
+ */
+MPACK_INLINE float mpack_tag_float_value(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_float, "tag is not a float!");
+    return tag->v.f;
+}
+
+/**
+ * Gets the double value of a double-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_double. (No check
+ * is performed if MPACK_DEBUG is not set.)
+ *
+ * @warning This does not convert between float and double tags! This can only
+ * be used if the type is @ref mpack_type_double.
+ *
+ * @see mpack_type_double
+ */
+MPACK_INLINE double mpack_tag_double_value(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_double, "tag is not a double!");
+    return tag->v.d;
+}
+
+/**
+ * Gets the number of elements in an array tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_array. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @see mpack_type_array
+ */
+MPACK_INLINE uint32_t mpack_tag_array_count(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_array, "tag is not an array!");
+    return tag->v.n;
+}
+
+/**
+ * Gets the number of key-value pairs in a map tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_map. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @see mpack_type_map
+ */
+MPACK_INLINE uint32_t mpack_tag_map_count(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_map, "tag is not a map!");
+    return tag->v.n;
+}
+
+/**
+ * Gets the length in bytes of a str-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_str. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @see mpack_type_str
+ */
+MPACK_INLINE uint32_t mpack_tag_str_length(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_str, "tag is not a str!");
+    return tag->v.l;
+}
+
+/**
+ * Gets the length in bytes of a bin-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_bin. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @see mpack_type_bin
+ */
+MPACK_INLINE uint32_t mpack_tag_bin_length(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_bin, "tag is not a bin!");
+    return tag->v.l;
+}
+
+#if MPACK_EXTENSIONS
+/**
+ * Gets the length in bytes of an ext-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_ext. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @see mpack_type_ext
+ */
+MPACK_INLINE uint32_t mpack_tag_ext_length(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!");
+    return tag->v.l;
+}
+
+/**
+ * Gets the extension type (exttype) of an ext-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_ext. (No check is
+ * performed if MPACK_DEBUG is not set.)
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @see mpack_type_ext
+ */
+MPACK_INLINE int8_t mpack_tag_ext_exttype(mpack_tag_t* tag) {
+    mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!");
+    return tag->exttype;
+}
+#endif
+
+/**
+ * Gets the length in bytes of a str-, bin- or ext-type tag.
+ *
+ * This asserts that the type in the tag is @ref mpack_type_str, @ref
+ * mpack_type_bin or @ref mpack_type_ext. (No check is performed if MPACK_DEBUG
+ * is not set.)
+ *
+ * @see mpack_type_str
+ * @see mpack_type_bin
+ * @see mpack_type_ext
+ */
+MPACK_INLINE uint32_t mpack_tag_bytes(mpack_tag_t* tag) {
+    #if MPACK_EXTENSIONS
+    mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin
+            || tag->type == mpack_type_ext, "tag is not a str, bin or ext!");
+    #else
+    mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin,
+            "tag is not a str or bin!");
+    #endif
+    return tag->v.l;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Other tag functions
+ * @{
+ */
+
+#if MPACK_EXTENSIONS
+/**
+ * The extension type for a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+#define MPACK_EXTTYPE_TIMESTAMP ((int8_t)(-1))
+#endif
+
+/**
+ * Compares two tags with an arbitrary fixed ordering. Returns 0 if the tags are
+ * equal, a negative integer if left comes before right, or a positive integer
+ * otherwise.
+ *
+ * \warning The ordering is not guaranteed to be preserved across MPack versions; do
+ * not rely on it in persistent data.
+ *
+ * \warning Floating point numbers are compared bit-for-bit, not using the language's
+ * operator==. This means that NaNs with matching representation will compare equal.
+ * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp().
+ *
+ * See mpack_tag_equal() for more information on when tags are considered equal.
+ */
+int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right);
+
+/**
+ * Compares two tags for equality. Tags are considered equal if the types are compatible
+ * and the values (for non-compound types) are equal.
+ *
+ * The field width of variable-width fields is ignored (and in fact is not stored
+ * in a tag), and positive numbers in signed integers are considered equal to their
+ * unsigned counterparts. So for example the value 1 stored as a positive fixint
+ * is equal to the value 1 stored in a 64-bit unsigned integer field.
+ *
+ * The "extension type" of an extension object is considered part of the value
+ * and must match exactly.
+ *
+ * \warning Floating point numbers are compared bit-for-bit, not using the language's
+ * operator==. This means that NaNs with matching representation will compare equal.
+ * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp().
+ */
+MPACK_INLINE bool mpack_tag_equal(mpack_tag_t left, mpack_tag_t right) {
+    return mpack_tag_cmp(left, right) == 0;
+}
+
+#if MPACK_DEBUG && MPACK_STDIO
+/**
+ * Generates a json-like debug description of the given tag into the given buffer.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ *
+ * The prefix is used to print the first few hexadecimal bytes of a bin or ext
+ * type. Pass NULL if not a bin or ext.
+ */
+void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size,
+        const char* prefix, size_t prefix_size);
+
+/**
+ * Generates a debug string description of the given tag into the given buffer.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size);
+
+/** @cond */
+
+/*
+ * A callback function for printing pseudo-JSON for debugging purposes.
+ *
+ * @see mpack_node_print_callback
+ */
+typedef void (*mpack_print_callback_t)(void* context, const char* data, size_t count);
+
+// helpers for printing debug output
+// i feel a bit like i'm re-implementing a buffered writer again...
+typedef struct mpack_print_t {
+    char* buffer;
+    size_t size;
+    size_t count;
+    mpack_print_callback_t callback;
+    void* context;
+} mpack_print_t;
+
+void mpack_print_append(mpack_print_t* print, const char* data, size_t count);
+
+MPACK_INLINE void mpack_print_append_cstr(mpack_print_t* print, const char* cstr) {
+    mpack_print_append(print, cstr, mpack_strlen(cstr));
+}
+
+void mpack_print_flush(mpack_print_t* print);
+
+void mpack_print_file_callback(void* context, const char* data, size_t count);
+
+/** @endcond */
+
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Deprecated Tag Generators
+ * @{
+ */
+
+/*
+ * "make" has been added to their names to disambiguate them from the
+ * value-fetching functions (e.g. mpack_tag_make_bool() vs
+ * mpack_tag_bool_value().)
+ *
+ * The length and count for all compound types was the wrong sign (int32_t
+ * instead of uint32_t.) These preserve the old behaviour; the new "make"
+ * functions have the correct sign.
+ */
+
+/** \deprecated Renamed to mpack_tag_make_nil(). */
+MPACK_INLINE mpack_tag_t mpack_tag_nil(void) {
+    return mpack_tag_make_nil();
+}
+
+/** \deprecated Renamed to mpack_tag_make_bool(). */
+MPACK_INLINE mpack_tag_t mpack_tag_bool(bool value) {
+    return mpack_tag_make_bool(value);
+}
+
+/** \deprecated Renamed to mpack_tag_make_true(). */
+MPACK_INLINE mpack_tag_t mpack_tag_true(void) {
+    return mpack_tag_make_true();
+}
+
+/** \deprecated Renamed to mpack_tag_make_false(). */
+MPACK_INLINE mpack_tag_t mpack_tag_false(void) {
+    return mpack_tag_make_false();
+}
+
+/** \deprecated Renamed to mpack_tag_make_int(). */
+MPACK_INLINE mpack_tag_t mpack_tag_int(int64_t value) {
+    return mpack_tag_make_int(value);
+}
+
+/** \deprecated Renamed to mpack_tag_make_uint(). */
+MPACK_INLINE mpack_tag_t mpack_tag_uint(uint64_t value) {
+    return mpack_tag_make_uint(value);
+}
+
+/** \deprecated Renamed to mpack_tag_make_float(). */
+MPACK_INLINE mpack_tag_t mpack_tag_float(float value) {
+    return mpack_tag_make_float(value);
+}
+
+/** \deprecated Renamed to mpack_tag_make_double(). */
+MPACK_INLINE mpack_tag_t mpack_tag_double(double value) {
+    return mpack_tag_make_double(value);
+}
+
+/** \deprecated Renamed to mpack_tag_make_array(). */
+MPACK_INLINE mpack_tag_t mpack_tag_array(int32_t count) {
+    return mpack_tag_make_array((uint32_t)count);
+}
+
+/** \deprecated Renamed to mpack_tag_make_map(). */
+MPACK_INLINE mpack_tag_t mpack_tag_map(int32_t count) {
+    return mpack_tag_make_map((uint32_t)count);
+}
+
+/** \deprecated Renamed to mpack_tag_make_str(). */
+MPACK_INLINE mpack_tag_t mpack_tag_str(int32_t length) {
+    return mpack_tag_make_str((uint32_t)length);
+}
+
+/** \deprecated Renamed to mpack_tag_make_bin(). */
+MPACK_INLINE mpack_tag_t mpack_tag_bin(int32_t length) {
+    return mpack_tag_make_bin((uint32_t)length);
+}
+
+#if MPACK_EXTENSIONS
+/** \deprecated Renamed to mpack_tag_make_ext(). */
+MPACK_INLINE mpack_tag_t mpack_tag_ext(int8_t exttype, int32_t length) {
+    return mpack_tag_make_ext(exttype, (uint32_t)length);
+}
+#endif
+
+/**
+ * @}
+ */
+
+/** @cond */
+
+/*
+ * Helpers to perform unaligned network-endian loads and stores
+ * at arbitrary addresses. Byte-swapping builtins are used if they
+ * are available and if they improve performance.
+ *
+ * These will remain available in the public API so feel free to
+ * use them for other purposes, but they are undocumented.
+ */
+
+MPACK_INLINE uint8_t mpack_load_u8(const char* p) {
+    return (uint8_t)p[0];
+}
+
+MPACK_INLINE uint16_t mpack_load_u16(const char* p) {
+    #ifdef MPACK_NHSWAP16
+    uint16_t val;
+    mpack_memcpy(&val, p, sizeof(val));
+    return MPACK_NHSWAP16(val);
+    #else
+    return (uint16_t)((((uint16_t)(uint8_t)p[0]) << 8) |
+           ((uint16_t)(uint8_t)p[1]));
+    #endif
+}
+
+MPACK_INLINE uint32_t mpack_load_u32(const char* p) {
+    #ifdef MPACK_NHSWAP32
+    uint32_t val;
+    mpack_memcpy(&val, p, sizeof(val));
+    return MPACK_NHSWAP32(val);
+    #else
+    return (((uint32_t)(uint8_t)p[0]) << 24) |
+           (((uint32_t)(uint8_t)p[1]) << 16) |
+           (((uint32_t)(uint8_t)p[2]) <<  8) |
+            ((uint32_t)(uint8_t)p[3]);
+    #endif
+}
+
+MPACK_INLINE uint64_t mpack_load_u64(const char* p) {
+    #ifdef MPACK_NHSWAP64
+    uint64_t val;
+    mpack_memcpy(&val, p, sizeof(val));
+    return MPACK_NHSWAP64(val);
+    #else
+    return (((uint64_t)(uint8_t)p[0]) << 56) |
+           (((uint64_t)(uint8_t)p[1]) << 48) |
+           (((uint64_t)(uint8_t)p[2]) << 40) |
+           (((uint64_t)(uint8_t)p[3]) << 32) |
+           (((uint64_t)(uint8_t)p[4]) << 24) |
+           (((uint64_t)(uint8_t)p[5]) << 16) |
+           (((uint64_t)(uint8_t)p[6]) <<  8) |
+            ((uint64_t)(uint8_t)p[7]);
+    #endif
+}
+
+MPACK_INLINE void mpack_store_u8(char* p, uint8_t val) {
+    uint8_t* u = (uint8_t*)p;
+    u[0] = val;
+}
+
+MPACK_INLINE void mpack_store_u16(char* p, uint16_t val) {
+    #ifdef MPACK_NHSWAP16
+    val = MPACK_NHSWAP16(val);
+    mpack_memcpy(p, &val, sizeof(val));
+    #else
+    uint8_t* u = (uint8_t*)p;
+    u[0] = (uint8_t)((val >> 8) & 0xFF);
+    u[1] = (uint8_t)( val       & 0xFF);
+    #endif
+}
+
+MPACK_INLINE void mpack_store_u32(char* p, uint32_t val) {
+    #ifdef MPACK_NHSWAP32
+    val = MPACK_NHSWAP32(val);
+    mpack_memcpy(p, &val, sizeof(val));
+    #else
+    uint8_t* u = (uint8_t*)p;
+    u[0] = (uint8_t)((val >> 24) & 0xFF);
+    u[1] = (uint8_t)((val >> 16) & 0xFF);
+    u[2] = (uint8_t)((val >>  8) & 0xFF);
+    u[3] = (uint8_t)( val        & 0xFF);
+    #endif
+}
+
+MPACK_INLINE void mpack_store_u64(char* p, uint64_t val) {
+    #ifdef MPACK_NHSWAP64
+    val = MPACK_NHSWAP64(val);
+    mpack_memcpy(p, &val, sizeof(val));
+    #else
+    uint8_t* u = (uint8_t*)p;
+    u[0] = (uint8_t)((val >> 56) & 0xFF);
+    u[1] = (uint8_t)((val >> 48) & 0xFF);
+    u[2] = (uint8_t)((val >> 40) & 0xFF);
+    u[3] = (uint8_t)((val >> 32) & 0xFF);
+    u[4] = (uint8_t)((val >> 24) & 0xFF);
+    u[5] = (uint8_t)((val >> 16) & 0xFF);
+    u[6] = (uint8_t)((val >>  8) & 0xFF);
+    u[7] = (uint8_t)( val        & 0xFF);
+    #endif
+}
+
+MPACK_INLINE int8_t  mpack_load_i8 (const char* p) {return (int8_t) mpack_load_u8 (p);}
+MPACK_INLINE int16_t mpack_load_i16(const char* p) {return (int16_t)mpack_load_u16(p);}
+MPACK_INLINE int32_t mpack_load_i32(const char* p) {return (int32_t)mpack_load_u32(p);}
+MPACK_INLINE int64_t mpack_load_i64(const char* p) {return (int64_t)mpack_load_u64(p);}
+MPACK_INLINE void mpack_store_i8 (char* p, int8_t  val) {mpack_store_u8 (p, (uint8_t) val);}
+MPACK_INLINE void mpack_store_i16(char* p, int16_t val) {mpack_store_u16(p, (uint16_t)val);}
+MPACK_INLINE void mpack_store_i32(char* p, int32_t val) {mpack_store_u32(p, (uint32_t)val);}
+MPACK_INLINE void mpack_store_i64(char* p, int64_t val) {mpack_store_u64(p, (uint64_t)val);}
+
+MPACK_INLINE float mpack_load_float(const char* p) {
+    MPACK_CHECK_FLOAT_ORDER();
+    MPACK_STATIC_ASSERT(sizeof(float) == sizeof(uint32_t), "float is wrong size??");
+    union {
+        float f;
+        uint32_t u;
+    } v;
+    v.u = mpack_load_u32(p);
+    return v.f;
+}
+
+MPACK_INLINE double mpack_load_double(const char* p) {
+    MPACK_CHECK_FLOAT_ORDER();
+    MPACK_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t), "double is wrong size??");
+    union {
+        double d;
+        uint64_t u;
+    } v;
+    v.u = mpack_load_u64(p);
+    return v.d;
+}
+
+MPACK_INLINE void mpack_store_float(char* p, float value) {
+    MPACK_CHECK_FLOAT_ORDER();
+    union {
+        float f;
+        uint32_t u;
+    } v;
+    v.f = value;
+    mpack_store_u32(p, v.u);
+}
+
+MPACK_INLINE void mpack_store_double(char* p, double value) {
+    MPACK_CHECK_FLOAT_ORDER();
+    union {
+        double d;
+        uint64_t u;
+    } v;
+    v.d = value;
+    mpack_store_u64(p, v.u);
+}
+
+/** @endcond */
+
+
+
+/** @cond */
+
+// Sizes in bytes for the various possible tags
+#define MPACK_TAG_SIZE_FIXUINT  1
+#define MPACK_TAG_SIZE_U8       2
+#define MPACK_TAG_SIZE_U16      3
+#define MPACK_TAG_SIZE_U32      5
+#define MPACK_TAG_SIZE_U64      9
+#define MPACK_TAG_SIZE_FIXINT   1
+#define MPACK_TAG_SIZE_I8       2
+#define MPACK_TAG_SIZE_I16      3
+#define MPACK_TAG_SIZE_I32      5
+#define MPACK_TAG_SIZE_I64      9
+#define MPACK_TAG_SIZE_FLOAT    5
+#define MPACK_TAG_SIZE_DOUBLE   9
+#define MPACK_TAG_SIZE_FIXARRAY 1
+#define MPACK_TAG_SIZE_ARRAY16  3
+#define MPACK_TAG_SIZE_ARRAY32  5
+#define MPACK_TAG_SIZE_FIXMAP   1
+#define MPACK_TAG_SIZE_MAP16    3
+#define MPACK_TAG_SIZE_MAP32    5
+#define MPACK_TAG_SIZE_FIXSTR   1
+#define MPACK_TAG_SIZE_STR8     2
+#define MPACK_TAG_SIZE_STR16    3
+#define MPACK_TAG_SIZE_STR32    5
+#define MPACK_TAG_SIZE_BIN8     2
+#define MPACK_TAG_SIZE_BIN16    3
+#define MPACK_TAG_SIZE_BIN32    5
+#define MPACK_TAG_SIZE_FIXEXT1  2
+#define MPACK_TAG_SIZE_FIXEXT2  2
+#define MPACK_TAG_SIZE_FIXEXT4  2
+#define MPACK_TAG_SIZE_FIXEXT8  2
+#define MPACK_TAG_SIZE_FIXEXT16 2
+#define MPACK_TAG_SIZE_EXT8     3
+#define MPACK_TAG_SIZE_EXT16    4
+#define MPACK_TAG_SIZE_EXT32    6
+
+// size in bytes for complete ext types
+#define MPACK_EXT_SIZE_TIMESTAMP4 (MPACK_TAG_SIZE_FIXEXT4 + 4)
+#define MPACK_EXT_SIZE_TIMESTAMP8 (MPACK_TAG_SIZE_FIXEXT8 + 8)
+#define MPACK_EXT_SIZE_TIMESTAMP12 (MPACK_TAG_SIZE_EXT8 + 12)
+
+/** @endcond */
+
+
+
+#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING
+/* Tracks the write state of compound elements (maps, arrays, */
+/* strings, binary blobs and extension types) */
+/** @cond */
+
+typedef struct mpack_track_element_t {
+    mpack_type_t type;
+    uint32_t left;
+
+    // indicates that a value still needs to be read/written for an already
+    // read/written key. left is not decremented until both key and value are
+    // read/written.
+    bool key_needs_value;
+} mpack_track_element_t;
+
+typedef struct mpack_track_t {
+    size_t count;
+    size_t capacity;
+    mpack_track_element_t* elements;
+} mpack_track_t;
+
+#if MPACK_INTERNAL
+mpack_error_t mpack_track_init(mpack_track_t* track);
+mpack_error_t mpack_track_grow(mpack_track_t* track);
+mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint32_t count);
+mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type);
+mpack_error_t mpack_track_element(mpack_track_t* track, bool read);
+mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read);
+mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, size_t count);
+mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, size_t count);
+mpack_error_t mpack_track_check_empty(mpack_track_t* track);
+mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel);
+#endif
+
+/** @endcond */
+#endif
+
+
+
+#if MPACK_INTERNAL
+/** @cond */
+
+
+
+/* Miscellaneous string functions */
+
+/**
+ * Returns true if the given UTF-8 string is valid.
+ */
+bool mpack_utf8_check(const char* str, size_t bytes);
+
+/**
+ * Returns true if the given UTF-8 string is valid and contains no null characters.
+ */
+bool mpack_utf8_check_no_null(const char* str, size_t bytes);
+
+/**
+ * Returns true if the given string has no null bytes.
+ */
+bool mpack_str_check_no_null(const char* str, size_t bytes);
+
+
+
+/** @endcond */
+#endif
+
+
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+MPACK_EXTERN_C_END
+MPACK_HEADER_END
+
+#endif
+
+
+/* mpack/mpack-writer.h.h */
+
+/**
+ * @file
+ *
+ * Declares the MPack Writer.
+ */
+
+#ifndef MPACK_WRITER_H
+#define MPACK_WRITER_H 1
+
+/* #include "mpack-common.h" */
+
+#if MPACK_WRITER
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+#if MPACK_WRITE_TRACKING
+struct mpack_track_t;
+#endif
+
+/**
+ * @defgroup writer Write API
+ *
+ * The MPack Write API encodes structured data of a fixed (hardcoded) schema to MessagePack.
+ *
+ * @{
+ */
+
+/**
+ * @def MPACK_WRITER_MINIMUM_BUFFER_SIZE
+ *
+ * The minimum buffer size for a writer with a flush function.
+ */
+#define MPACK_WRITER_MINIMUM_BUFFER_SIZE 32
+
+/**
+ * A buffered MessagePack encoder.
+ *
+ * The encoder wraps an existing buffer and, optionally, a flush function.
+ * This allows efficiently encoding to an in-memory buffer or to a stream.
+ *
+ * All write operations are synchronous; they will block until the
+ * data is fully written, or an error occurs.
+ */
+typedef struct mpack_writer_t mpack_writer_t;
+
+/**
+ * The MPack writer's flush function to flush the buffer to the output stream.
+ * It should flag an appropriate error on the writer if flushing fails (usually
+ * mpack_error_io or mpack_error_memory.)
+ *
+ * The specified context for callbacks is at writer->context.
+ */
+typedef void (*mpack_writer_flush_t)(mpack_writer_t* writer, const char* buffer, size_t count);
+
+/**
+ * An error handler function to be called when an error is flagged on
+ * the writer.
+ *
+ * The error handler will only be called once on the first error flagged;
+ * any subsequent writes and errors are ignored, and the writer is
+ * permanently in that error state.
+ *
+ * MPack is safe against non-local jumps out of error handler callbacks.
+ * This means you are allowed to longjmp or throw an exception (in C++,
+ * Objective-C, or with SEH) out of this callback.
+ *
+ * Bear in mind when using longjmp that local non-volatile variables that
+ * have changed are undefined when setjmp() returns, so you can't put the
+ * writer on the stack in the same activation frame as the setjmp without
+ * declaring it volatile.
+ *
+ * You must still eventually destroy the writer. It is not destroyed
+ * automatically when an error is flagged. It is safe to destroy the
+ * writer within this error callback, but you will either need to perform
+ * a non-local jump, or store something in your context to identify
+ * that the writer is destroyed since any future accesses to it cause
+ * undefined behavior.
+ */
+typedef void (*mpack_writer_error_t)(mpack_writer_t* writer, mpack_error_t error);
+
+/**
+ * A teardown function to be called when the writer is destroyed.
+ */
+typedef void (*mpack_writer_teardown_t)(mpack_writer_t* writer);
+
+/* Hide internals from documentation */
+/** @cond */
+
+struct mpack_writer_t {
+    #if MPACK_COMPATIBILITY
+    mpack_version_t version;          /* Version of the MessagePack spec to write */
+    #endif
+    mpack_writer_flush_t flush;       /* Function to write bytes to the output stream */
+    mpack_writer_error_t error_fn;    /* Function to call on error */
+    mpack_writer_teardown_t teardown; /* Function to teardown the context on destroy */
+    void* context;                    /* Context for writer callbacks */
+
+    char* buffer;         /* Byte buffer */
+    char* current;        /* Current position within the buffer */
+    char* end;            /* The end of the buffer */
+    mpack_error_t error;  /* Error state */
+
+    #if MPACK_WRITE_TRACKING
+    mpack_track_t track; /* Stack of map/array/str/bin/ext writes */
+    #endif
+
+    #ifdef MPACK_MALLOC
+    /* Reserved. You can use this space to allocate a custom
+     * context in order to reduce heap allocations. */
+    void* reserved[2];
+    #endif
+};
+
+#if MPACK_WRITE_TRACKING
+void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count);
+void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type);
+void mpack_writer_track_element(mpack_writer_t* writer);
+void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count);
+#else
+MPACK_INLINE void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint32_t count) {
+    MPACK_UNUSED(writer);
+    MPACK_UNUSED(type);
+    MPACK_UNUSED(count);
+}
+MPACK_INLINE void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) {
+    MPACK_UNUSED(writer);
+    MPACK_UNUSED(type);
+}
+MPACK_INLINE void mpack_writer_track_element(mpack_writer_t* writer) {
+    MPACK_UNUSED(writer);
+}
+MPACK_INLINE void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) {
+    MPACK_UNUSED(writer);
+    MPACK_UNUSED(count);
+}
+#endif
+
+/** @endcond */
+
+/**
+ * @name Lifecycle Functions
+ * @{
+ */
+
+/**
+ * Initializes an MPack writer with the given buffer. The writer
+ * does not assume ownership of the buffer.
+ *
+ * Trying to write past the end of the buffer will result in mpack_error_too_big
+ * unless a flush function is set with mpack_writer_set_flush(). To use the data
+ * without flushing, call mpack_writer_buffer_used() to determine the number of
+ * bytes written.
+ *
+ * @param writer The MPack writer.
+ * @param buffer The buffer into which to write MessagePack data.
+ * @param size The size of the buffer.
+ */
+void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size);
+
+#ifdef MPACK_MALLOC
+/**
+ * Initializes an MPack writer using a growable buffer.
+ *
+ * The data is placed in the given data pointer if and when the writer
+ * is destroyed without error. The data pointer is NULL during writing,
+ * and will remain NULL if an error occurs.
+ *
+ * The allocated data must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_memory if the buffer fails to grow when
+ * flushing.
+ *
+ * @param writer The MPack writer.
+ * @param data Where to place the allocated data.
+ * @param size Where to write the size of the data.
+ */
+void mpack_writer_init_growable(mpack_writer_t* writer, char** data, size_t* size);
+#endif
+
+/**
+ * Initializes an MPack writer directly into an error state. Use this if you
+ * are writing a wrapper to mpack_writer_init() which can fail its setup.
+ */
+void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error);
+
+#if MPACK_STDIO
+/**
+ * Initializes an MPack writer that writes to a file.
+ *
+ * @throws mpack_error_memory if allocation fails
+ * @throws mpack_error_io if the file cannot be opened
+ */
+void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename);
+
+/**
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_writer_init_filename().
+ */
+MPACK_INLINE void mpack_writer_init_file(mpack_writer_t* writer, const char* filename) {
+    mpack_writer_init_filename(writer, filename);
+}
+
+/**
+ * Initializes an MPack writer that writes to a libc FILE. This can be used to
+ * write to stdout or stderr, or to a file opened separately.
+ *
+ * @param writer The MPack writer.
+ * @param stdfile The FILE.
+ * @param close_when_done If true, fclose() will be called on the FILE when it
+ *         is no longer needed. If false, the file will not be flushed or
+ *         closed when writing is done.
+ *
+ * @note The writer is buffered. If you want to write other data to the FILE in
+ *         between messages, you must flush it first.
+ *
+ * @see mpack_writer_flush_message
+ */
+void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* stdfile, bool close_when_done);
+#endif
+
+/** @cond */
+
+#define mpack_writer_init_stack_line_ex(line, writer) \
+    char mpack_buf_##line[MPACK_STACK_SIZE]; \
+    mpack_writer_init(writer, mpack_buf_##line, sizeof(mpack_buf_##line))
+
+#define mpack_writer_init_stack_line(line, writer) \
+    mpack_writer_init_stack_line_ex(line, writer)
+
+/*
+ * Initializes an MPack writer using stack space as a buffer. A flush function
+ * should be added to the writer to flush the buffer.
+ *
+ * This is currently undocumented since it's not entirely useful on its own.
+ */
+
+#define mpack_writer_init_stack(writer) \
+    mpack_writer_init_stack_line(__LINE__, (writer))
+
+/** @endcond */
+
+/**
+ * Cleans up the MPack writer, flushing and closing the underlying stream,
+ * if any. Returns the final error state of the writer.
+ *
+ * No flushing is performed if the writer is in an error state. The attached
+ * teardown function is called whether or not the writer is in an error state.
+ *
+ * This will assert in tracking mode if the writer is not in an error
+ * state and has any unclosed compound types. If you want to cancel
+ * writing in the middle of a document, you need to flag an error on
+ * the writer before destroying it (such as mpack_error_data).
+ *
+ * Note that a writer may raise an error and call your error handler during
+ * the final flush. It is safe to longjmp or throw out of this error handler,
+ * but if you do, the writer will not be destroyed, and the teardown function
+ * will not be called. You can still get the writer's error state, and you
+ * must call @ref mpack_writer_destroy() again. (The second call is guaranteed
+ * not to call your error handler again since the writer is already in an error
+ * state.)
+ *
+ * @see mpack_writer_set_error_handler
+ * @see mpack_writer_set_flush
+ * @see mpack_writer_set_teardown
+ * @see mpack_writer_flag_error
+ * @see mpack_error_data
+ */
+mpack_error_t mpack_writer_destroy(mpack_writer_t* writer);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Configuration
+ * @{
+ */
+
+#if MPACK_COMPATIBILITY
+/**
+ * Sets the version of the MessagePack spec that will be generated.
+ *
+ * This can be used to interface with older libraries that do not support
+ * the newest MessagePack features (such as the @c str8 type.)
+ *
+ * @note This requires @ref MPACK_COMPATIBILITY.
+ */
+MPACK_INLINE void mpack_writer_set_version(mpack_writer_t* writer, mpack_version_t version) {
+    writer->version = version;
+}
+#endif
+
+/**
+ * Sets the custom pointer to pass to the writer callbacks, such as flush
+ * or teardown.
+ *
+ * @param writer The MPack writer.
+ * @param context User data to pass to the writer callbacks.
+ *
+ * @see mpack_writer_context()
+ */
+MPACK_INLINE void mpack_writer_set_context(mpack_writer_t* writer, void* context) {
+    writer->context = context;
+}
+
+/**
+ * Returns the custom context for writer callbacks.
+ *
+ * @see mpack_writer_set_context
+ * @see mpack_writer_set_flush
+ */
+MPACK_INLINE void* mpack_writer_context(mpack_writer_t* writer) {
+    return writer->context;
+}
+
+/**
+ * Sets the flush function to write out the data when the buffer is full.
+ *
+ * If no flush function is used, trying to write past the end of the
+ * buffer will result in mpack_error_too_big.
+ *
+ * This should normally be used with mpack_writer_set_context() to register
+ * a custom pointer to pass to the flush function.
+ *
+ * @param writer The MPack writer.
+ * @param flush The function to write out data from the buffer.
+ *
+ * @see mpack_writer_context()
+ */
+void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush);
+
+/**
+ * Sets the error function to call when an error is flagged on the writer.
+ *
+ * This should normally be used with mpack_writer_set_context() to register
+ * a custom pointer to pass to the error function.
+ *
+ * See the definition of mpack_writer_error_t for more information about
+ * what you can do from an error callback.
+ *
+ * @see mpack_writer_error_t
+ * @param writer The MPack writer.
+ * @param error_fn The function to call when an error is flagged on the writer.
+ */
+MPACK_INLINE void mpack_writer_set_error_handler(mpack_writer_t* writer, mpack_writer_error_t error_fn) {
+    writer->error_fn = error_fn;
+}
+
+/**
+ * Sets the teardown function to call when the writer is destroyed.
+ *
+ * This should normally be used with mpack_writer_set_context() to register
+ * a custom pointer to pass to the teardown function.
+ *
+ * @param writer The MPack writer.
+ * @param teardown The function to call when the writer is destroyed.
+ */
+MPACK_INLINE void mpack_writer_set_teardown(mpack_writer_t* writer, mpack_writer_teardown_t teardown) {
+    writer->teardown = teardown;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Core Writer Functions
+ * @{
+ */
+
+/**
+ * Flushes any buffered data to the underlying stream.
+ *
+ * If write tracking is enabled, this will break and flag @ref
+ * mpack_error_bug if the writer has any open compound types, ensuring
+ * that no compound types are still open. This prevents a "missing
+ * finish" bug from causing a never-ending message.
+ *
+ * If the writer is connected to a socket and you are keeping it open,
+ * you will want to call this after writing a message (or set of
+ * messages) so that the data is actually sent.
+ *
+ * It is not necessary to call this if you are not keeping the writer
+ * open afterwards. You can just call `mpack_writer_destroy()`, and it
+ * will flush before cleaning up.
+ *
+ * This will assert if no flush function is assigned to the writer.
+ */
+void mpack_writer_flush_message(mpack_writer_t* writer);
+
+/**
+ * Returns the number of bytes currently stored in the buffer. This
+ * may be less than the total number of bytes written if bytes have
+ * been flushed to an underlying stream.
+ */
+MPACK_INLINE size_t mpack_writer_buffer_used(mpack_writer_t* writer) {
+    return (size_t)(writer->current - writer->buffer);
+}
+
+/**
+ * Returns the amount of space left in the buffer. This may be reset
+ * after a write if bytes are flushed to an underlying stream.
+ */
+MPACK_INLINE size_t mpack_writer_buffer_left(mpack_writer_t* writer) {
+    return (size_t)(writer->end - writer->current);
+}
+
+/**
+ * Returns the (current) size of the buffer. This may change after a write if
+ * the flush callback changes the buffer.
+ */
+MPACK_INLINE size_t mpack_writer_buffer_size(mpack_writer_t* writer) {
+    return (size_t)(writer->end - writer->buffer);
+}
+
+/**
+ * Places the writer in the given error state, calling the error callback if one
+ * is set.
+ *
+ * This allows you to externally flag errors, for example if you are validating
+ * data as you write it, or if you want to cancel writing in the middle of a
+ * document. (The writer will assert if you try to destroy it without error and
+ * with unclosed compound types. In this case you should flag mpack_error_data
+ * before destroying it.)
+ *
+ * If the writer is already in an error state, this call is ignored and no
+ * error callback is called.
+ *
+ * @see mpack_writer_destroy
+ * @see mpack_error_data
+ */
+void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error);
+
+/**
+ * Queries the error state of the MPack writer.
+ *
+ * If a writer is in an error state, you should discard all data since the
+ * last time the error flag was checked. The error flag cannot be cleared.
+ */
+MPACK_INLINE mpack_error_t mpack_writer_error(mpack_writer_t* writer) {
+    return writer->error;
+}
+
+/**
+ * Writes a MessagePack object header (an MPack Tag.)
+ *
+ * If the value is a map, array, string, binary or extension type, the
+ * containing elements or bytes must be written separately and the
+ * appropriate finish function must be called (as though one of the
+ * mpack_start_*() functions was called.)
+ *
+ * @see mpack_write_bytes()
+ * @see mpack_finish_map()
+ * @see mpack_finish_array()
+ * @see mpack_finish_str()
+ * @see mpack_finish_bin()
+ * @see mpack_finish_ext()
+ * @see mpack_finish_type()
+ */
+void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t tag);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Integers
+ * @{
+ */
+
+/** Writes an 8-bit integer in the most efficient packing available. */
+void mpack_write_i8(mpack_writer_t* writer, int8_t value);
+
+/** Writes a 16-bit integer in the most efficient packing available. */
+void mpack_write_i16(mpack_writer_t* writer, int16_t value);
+
+/** Writes a 32-bit integer in the most efficient packing available. */
+void mpack_write_i32(mpack_writer_t* writer, int32_t value);
+
+/** Writes a 64-bit integer in the most efficient packing available. */
+void mpack_write_i64(mpack_writer_t* writer, int64_t value);
+
+/** Writes an integer in the most efficient packing available. */
+MPACK_INLINE void mpack_write_int(mpack_writer_t* writer, int64_t value) {
+    mpack_write_i64(writer, value);
+}
+
+/** Writes an 8-bit unsigned integer in the most efficient packing available. */
+void mpack_write_u8(mpack_writer_t* writer, uint8_t value);
+
+/** Writes an 16-bit unsigned integer in the most efficient packing available. */
+void mpack_write_u16(mpack_writer_t* writer, uint16_t value);
+
+/** Writes an 32-bit unsigned integer in the most efficient packing available. */
+void mpack_write_u32(mpack_writer_t* writer, uint32_t value);
+
+/** Writes an 64-bit unsigned integer in the most efficient packing available. */
+void mpack_write_u64(mpack_writer_t* writer, uint64_t value);
+
+/** Writes an unsigned integer in the most efficient packing available. */
+MPACK_INLINE void mpack_write_uint(mpack_writer_t* writer, uint64_t value) {
+    mpack_write_u64(writer, value);
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Other Basic Types
+ * @{
+ */
+
+/** Writes a float. */
+void mpack_write_float(mpack_writer_t* writer, float value);
+
+/** Writes a double. */
+void mpack_write_double(mpack_writer_t* writer, double value);
+
+/** Writes a boolean. */
+void mpack_write_bool(mpack_writer_t* writer, bool value);
+
+/** Writes a boolean with value true. */
+void mpack_write_true(mpack_writer_t* writer);
+
+/** Writes a boolean with value false. */
+void mpack_write_false(mpack_writer_t* writer);
+
+/** Writes a nil. */
+void mpack_write_nil(mpack_writer_t* writer);
+
+/** Write a pre-encoded messagepack object */
+void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes);
+
+#if MPACK_EXTENSIONS
+/**
+ * Writes a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @param writer The writer
+ * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z.
+ * @param nanoseconds The additional number of nanoseconds from 0 to 999,999,999 inclusive.
+ */
+void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds);
+
+/**
+ * Writes a timestamp with the given number of seconds (and zero nanoseconds).
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @param writer The writer
+ * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z.
+ */
+MPACK_INLINE void mpack_write_timestamp_seconds(mpack_writer_t* writer, int64_t seconds) {
+    mpack_write_timestamp(writer, seconds, 0);
+}
+
+/**
+ * Writes a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+MPACK_INLINE void mpack_write_timestamp_struct(mpack_writer_t* writer, mpack_timestamp_t timestamp) {
+    mpack_write_timestamp(writer, timestamp.seconds, timestamp.nanoseconds);
+}
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Map and Array Functions
+ * @{
+ */
+
+/**
+ * Opens an array.
+ *
+ * `count` elements must follow, and mpack_finish_array() must be called
+ * when done.
+ *
+ * @see mpack_finish_array()
+ */
+void mpack_start_array(mpack_writer_t* writer, uint32_t count);
+
+/**
+ * Opens a map.
+ *
+ * `count * 2` elements must follow, and mpack_finish_map() must be called
+ * when done.
+ *
+ * Remember that while map elements in MessagePack are implicitly ordered,
+ * they are not ordered in JSON. If you need elements to be read back
+ * in the order they are written, consider use an array instead.
+ *
+ * @see mpack_finish_map()
+ */
+void mpack_start_map(mpack_writer_t* writer, uint32_t count);
+
+/**
+ * Finishes writing an array.
+ *
+ * This should be called only after a corresponding call to mpack_start_array()
+ * and after the array contents are written.
+ *
+ * This will track writes to ensure that the correct number of elements are written.
+ *
+ * @see mpack_start_array()
+ */
+MPACK_INLINE void mpack_finish_array(mpack_writer_t* writer) {
+    mpack_writer_track_pop(writer, mpack_type_array);
+}
+
+/**
+ * Finishes writing a map.
+ *
+ * This should be called only after a corresponding call to mpack_start_map()
+ * and after the map contents are written.
+ *
+ * This will track writes to ensure that the correct number of elements are written.
+ *
+ * @see mpack_start_map()
+ */
+MPACK_INLINE void mpack_finish_map(mpack_writer_t* writer) {
+    mpack_writer_track_pop(writer, mpack_type_map);
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Data Helpers
+ * @{
+ */
+
+/**
+ * Writes a string.
+ *
+ * To stream a string in chunks, use mpack_start_str() instead.
+ *
+ * MPack does not care about the underlying encoding, but UTF-8 is highly
+ * recommended, especially for compatibility with JSON. You should consider
+ * calling mpack_write_utf8() instead, especially if you will be reading
+ * it back as UTF-8.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ */
+void mpack_write_str(mpack_writer_t* writer, const char* str, uint32_t length);
+
+/**
+ * Writes a string, ensuring that it is valid UTF-8.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ *
+ * @throws mpack_error_invalid if the string is not valid UTF-8
+ */
+void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length);
+
+/**
+ * Writes a null-terminated string. (The null-terminator is not written.)
+ *
+ * MPack does not care about the underlying encoding, but UTF-8 is highly
+ * recommended, especially for compatibility with JSON. You should consider
+ * calling mpack_write_utf8_cstr() instead, especially if you will be reading
+ * it back as UTF-8.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ */
+void mpack_write_cstr(mpack_writer_t* writer, const char* cstr);
+
+/**
+ * Writes a null-terminated string, or a nil node if the given cstr pointer
+ * is NULL. (The null-terminator is not written.)
+ *
+ * MPack does not care about the underlying encoding, but UTF-8 is highly
+ * recommended, especially for compatibility with JSON. You should consider
+ * calling mpack_write_utf8_cstr_or_nil() instead, especially if you will
+ * be reading it back as UTF-8.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ */
+void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr);
+
+/**
+ * Writes a null-terminated string, ensuring that it is valid UTF-8. (The
+ * null-terminator is not written.)
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ *
+ * @throws mpack_error_invalid if the string is not valid UTF-8
+ */
+void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr);
+
+/**
+ * Writes a null-terminated string ensuring that it is valid UTF-8, or
+ * writes nil if the given cstr pointer is NULL. (The null-terminator
+ * is not written.)
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * You should not call mpack_finish_str() after calling this; this
+ * performs both start and finish.
+ *
+ * @throws mpack_error_invalid if the string is not valid UTF-8
+ */
+void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr);
+
+/**
+ * Writes a binary blob.
+ *
+ * To stream a binary blob in chunks, use mpack_start_bin() instead.
+ *
+ * You should not call mpack_finish_bin() after calling this; this
+ * performs both start and finish.
+ */
+void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count);
+
+#if MPACK_EXTENSIONS
+/**
+ * Writes an extension type.
+ *
+ * To stream an extension blob in chunks, use mpack_start_ext() instead.
+ *
+ * Extension types [0, 127] are available for application-specific types. Extension
+ * types [-128, -1] are reserved for future extensions of MessagePack.
+ *
+ * You should not call mpack_finish_ext() after calling this; this
+ * performs both start and finish.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Chunked Data Functions
+ * @{
+ */
+
+/**
+ * Opens a string. `count` bytes should be written with calls to
+ * mpack_write_bytes(), and mpack_finish_str() should be called
+ * when done.
+ *
+ * To write an entire string at once, use mpack_write_str() or
+ * mpack_write_cstr() instead.
+ *
+ * MPack does not care about the underlying encoding, but UTF-8 is highly
+ * recommended, especially for compatibility with JSON.
+ */
+void mpack_start_str(mpack_writer_t* writer, uint32_t count);
+
+/**
+ * Opens a binary blob. `count` bytes should be written with calls to
+ * mpack_write_bytes(), and mpack_finish_bin() should be called
+ * when done.
+ */
+void mpack_start_bin(mpack_writer_t* writer, uint32_t count);
+
+#if MPACK_EXTENSIONS
+/**
+ * Opens an extension type. `count` bytes should be written with calls
+ * to mpack_write_bytes(), and mpack_finish_ext() should be called
+ * when done.
+ *
+ * Extension types [0, 127] are available for application-specific types. Extension
+ * types [-128, -1] are reserved for future extensions of MessagePack.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count);
+#endif
+
+/**
+ * Writes a portion of bytes for a string, binary blob or extension type which
+ * was opened by mpack_write_tag() or one of the mpack_start_*() functions.
+ *
+ * This can be called multiple times to write the data in chunks, as long as
+ * the total amount of bytes written matches the count given when the compound
+ * type was started.
+ *
+ * The corresponding mpack_finish_*() function must be called when done.
+ *
+ * To write an entire string, binary blob or extension type at
+ * once, use one of the mpack_write_*() functions instead.
+ *
+ * @see mpack_write_tag()
+ * @see mpack_start_str()
+ * @see mpack_start_bin()
+ * @see mpack_start_ext()
+ * @see mpack_finish_str()
+ * @see mpack_finish_bin()
+ * @see mpack_finish_ext()
+ * @see mpack_finish_type()
+ */
+void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count);
+
+/**
+ * Finishes writing a string.
+ *
+ * This should be called only after a corresponding call to mpack_start_str()
+ * and after the string bytes are written with mpack_write_bytes().
+ *
+ * This will track writes to ensure that the correct number of elements are written.
+ *
+ * @see mpack_start_str()
+ * @see mpack_write_bytes()
+ */
+MPACK_INLINE void mpack_finish_str(mpack_writer_t* writer) {
+    mpack_writer_track_pop(writer, mpack_type_str);
+}
+
+/**
+ * Finishes writing a binary blob.
+ *
+ * This should be called only after a corresponding call to mpack_start_bin()
+ * and after the binary bytes are written with mpack_write_bytes().
+ *
+ * This will track writes to ensure that the correct number of bytes are written.
+ *
+ * @see mpack_start_bin()
+ * @see mpack_write_bytes()
+ */
+MPACK_INLINE void mpack_finish_bin(mpack_writer_t* writer) {
+    mpack_writer_track_pop(writer, mpack_type_bin);
+}
+
+#if MPACK_EXTENSIONS
+/**
+ * Finishes writing an extended type binary data blob.
+ *
+ * This should be called only after a corresponding call to mpack_start_bin()
+ * and after the binary bytes are written with mpack_write_bytes().
+ *
+ * This will track writes to ensure that the correct number of bytes are written.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @see mpack_start_ext()
+ * @see mpack_write_bytes()
+ */
+MPACK_INLINE void mpack_finish_ext(mpack_writer_t* writer) {
+    mpack_writer_track_pop(writer, mpack_type_ext);
+}
+#endif
+
+/**
+ * Finishes writing the given compound type.
+ *
+ * This will track writes to ensure that the correct number of elements
+ * or bytes are written.
+ *
+ * This can be called with the appropriate type instead the corresponding
+ * mpack_finish_*() function if you want to finish a dynamic type.
+ */
+MPACK_INLINE void mpack_finish_type(mpack_writer_t* writer, mpack_type_t type) {
+    mpack_writer_track_pop(writer, type);
+}
+
+/**
+ * @}
+ */
+
+#if MPACK_HAS_GENERIC && !defined(__cplusplus)
+
+/**
+ * @name Type-Generic Writers
+ * @{
+ */
+
+/**
+ * @def mpack_write(writer, value)
+ *
+ * Type-generic writer for primitive types.
+ *
+ * The compiler will dispatch to an appropriate write function based
+ * on the type of the @a value parameter.
+ *
+ * @note This requires C11 `_Generic` support. (A set of inline overloads
+ * are used in C++ to provide the same functionality.)
+ *
+ * @warning In C11, the indentifiers `true`, `false` and `NULL` are
+ * all of type `int`, not `bool` or `void*`! They will emit unexpected
+ * types when passed uncast, so be careful when using them.
+ */
+#define mpack_write(writer, value) \
+    _Generic(((void)0, value),                      \
+              int8_t: mpack_write_i8,               \
+             int16_t: mpack_write_i16,              \
+             int32_t: mpack_write_i32,              \
+             int64_t: mpack_write_i64,              \
+             uint8_t: mpack_write_u8,               \
+            uint16_t: mpack_write_u16,              \
+            uint32_t: mpack_write_u32,              \
+            uint64_t: mpack_write_u64,              \
+                bool: mpack_write_bool,             \
+               float: mpack_write_float,            \
+              double: mpack_write_double,           \
+              char *: mpack_write_cstr_or_nil,      \
+        const char *: mpack_write_cstr_or_nil       \
+    )(writer, value)
+
+/**
+ * @def mpack_write_kv(writer, key, value)
+ *
+ * Type-generic writer for key-value pairs of null-terminated string
+ * keys and primitive values.
+ *
+ * @warning @a writer may be evaluated multiple times.
+ *
+ * @warning In C11, the indentifiers `true`, `false` and `NULL` are
+ * all of type `int`, not `bool` or `void*`! They will emit unexpected
+ * types when passed uncast, so be careful when using them.
+ *
+ * @param writer The writer.
+ * @param key A null-terminated C string.
+ * @param value A primitive type supported by mpack_write().
+ */
+#define mpack_write_kv(writer, key, value) do {     \
+    mpack_write_cstr(writer, key);                  \
+    mpack_write(writer, value);                     \
+} while (0)
+
+/**
+ * @}
+ */
+
+#endif // MPACK_HAS_GENERIC && !defined(__cplusplus)
+
+// The rest of this file contains C++ overloads, so we end extern "C" here.
+MPACK_EXTERN_C_END
+
+#if defined(__cplusplus) || defined(MPACK_DOXYGEN)
+
+/**
+ * @name C++ write overloads
+ * @{
+ */
+
+/*
+ * C++ generic writers for primitive values
+ */
+
+#ifdef MPACK_DOXYGEN
+#undef mpack_write
+#undef mpack_write_kv
+#endif
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, int8_t value) {
+    mpack_write_i8(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, int16_t value) {
+    mpack_write_i16(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, int32_t value) {
+    mpack_write_i32(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, int64_t value) {
+    mpack_write_i64(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint8_t value) {
+    mpack_write_u8(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint16_t value) {
+    mpack_write_u16(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint32_t value) {
+    mpack_write_u32(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint64_t value) {
+    mpack_write_u64(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, bool value) {
+    mpack_write_bool(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, float value) {
+    mpack_write_float(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, double value) {
+    mpack_write_double(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, char *value) {
+    mpack_write_cstr_or_nil(writer, value);
+}
+
+MPACK_INLINE void mpack_write(mpack_writer_t* writer, const char *value) {
+    mpack_write_cstr_or_nil(writer, value);
+}
+
+/* C++ generic write for key-value pairs */
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int8_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_i8(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int16_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_i16(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int32_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_i32(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int64_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_i64(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint8_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_u8(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint16_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_u16(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint32_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_u32(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint64_t value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_u64(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, bool value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_bool(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, float value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_float(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, double value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_double(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, char *value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_cstr_or_nil(writer, value);
+}
+
+MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, const char *value) {
+    mpack_write_cstr(writer, key);
+    mpack_write_cstr_or_nil(writer, value);
+}
+
+/**
+ * @}
+ */
+
+#endif /* __cplusplus */
+
+/**
+ * @}
+ */
+
+MPACK_HEADER_END
+
+#endif // MPACK_WRITER
+
+#endif
+
+/* mpack/mpack-reader.h.h */
+
+/**
+ * @file
+ *
+ * Declares the core MPack Tag Reader.
+ */
+
+#ifndef MPACK_READER_H
+#define MPACK_READER_H 1
+
+/* #include "mpack-common.h" */
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+#if MPACK_READER
+
+#if MPACK_READ_TRACKING
+struct mpack_track_t;
+#endif
+
+// The denominator to determine whether a read is a small
+// fraction of the buffer size.
+#define MPACK_READER_SMALL_FRACTION_DENOMINATOR 32
+
+/**
+ * @defgroup reader Reader API
+ *
+ * The MPack Reader API contains functions for imperatively reading dynamically
+ * typed data from a MessagePack stream.
+ *
+ * See @ref docs/reader.md for examples.
+ *
+ * @note If you are not writing code for an embedded device (or otherwise do
+ * not need maximum performance with minimal memory usage), you should not use
+ * this. You probably want to use the @link node Node API@endlink instead.
+ *
+ * This forms the basis of the @link expect Expect API@endlink, which can be
+ * used to interpret the stream of elements in expected types and value ranges.
+ *
+ * @{
+ */
+
+/**
+ * @def MPACK_READER_MINIMUM_BUFFER_SIZE
+ *
+ * The minimum buffer size for a reader with a fill function.
+ */
+#define MPACK_READER_MINIMUM_BUFFER_SIZE 32
+
+/**
+ * A buffered MessagePack decoder.
+ *
+ * The decoder wraps an existing buffer and, optionally, a fill function.
+ * This allows efficiently decoding data from existing memory buffers, files,
+ * streams, etc.
+ *
+ * All read operations are synchronous; they will block until the
+ * requested data is fully read, or an error occurs.
+ *
+ * This structure is opaque; its fields should not be accessed outside
+ * of MPack.
+ */
+typedef struct mpack_reader_t mpack_reader_t;
+
+/**
+ * The MPack reader's fill function. It should fill the buffer with at
+ * least one byte and at most the given @c count, returning the number
+ * of bytes written to the buffer.
+ *
+ * In case of error, it should flag an appropriate error on the reader
+ * (usually @ref mpack_error_io), or simply return zero. If zero is
+ * returned, mpack_error_io is raised.
+ *
+ * @note When reading from a stream, you should only copy and return
+ * the bytes that are immediately available. It is always safe to return
+ * less than the requested count as long as some non-zero number of bytes
+ * are read; if more bytes are needed, the read function will simply be
+ * called again.
+ *
+ * @see mpack_reader_context()
+ */
+typedef size_t (*mpack_reader_fill_t)(mpack_reader_t* reader, char* buffer, size_t count);
+
+/**
+ * The MPack reader's skip function. It should discard the given number
+ * of bytes from the source (for example by seeking forward.)
+ *
+ * In case of error, it should flag an appropriate error on the reader.
+ *
+ * @see mpack_reader_context()
+ */
+typedef void (*mpack_reader_skip_t)(mpack_reader_t* reader, size_t count);
+
+/**
+ * An error handler function to be called when an error is flagged on
+ * the reader.
+ *
+ * The error handler will only be called once on the first error flagged;
+ * any subsequent reads and errors are ignored, and the reader is
+ * permanently in that error state.
+ *
+ * MPack is safe against non-local jumps out of error handler callbacks.
+ * This means you are allowed to longjmp or throw an exception (in C++,
+ * Objective-C, or with SEH) out of this callback.
+ *
+ * Bear in mind when using longjmp that local non-volatile variables that
+ * have changed are undefined when setjmp() returns, so you can't put the
+ * reader on the stack in the same activation frame as the setjmp without
+ * declaring it volatile.
+ *
+ * You must still eventually destroy the reader. It is not destroyed
+ * automatically when an error is flagged. It is safe to destroy the
+ * reader within this error callback, but you will either need to perform
+ * a non-local jump, or store something in your context to identify
+ * that the reader is destroyed since any future accesses to it cause
+ * undefined behavior.
+ */
+typedef void (*mpack_reader_error_t)(mpack_reader_t* reader, mpack_error_t error);
+
+/**
+ * A teardown function to be called when the reader is destroyed.
+ */
+typedef void (*mpack_reader_teardown_t)(mpack_reader_t* reader);
+
+/* Hide internals from documentation */
+/** @cond */
+
+struct mpack_reader_t {
+    void* context;                    /* Context for reader callbacks */
+    mpack_reader_fill_t fill;         /* Function to read bytes into the buffer */
+    mpack_reader_error_t error_fn;    /* Function to call on error */
+    mpack_reader_teardown_t teardown; /* Function to teardown the context on destroy */
+    mpack_reader_skip_t skip;         /* Function to skip bytes from the source */
+
+    char* buffer;       /* Writeable byte buffer */
+    size_t size;        /* Size of the buffer */
+
+    const char* data;   /* Current data pointer (in the buffer, if it is used) */
+    const char* end;    /* The end of available data (in the buffer, if it is used) */
+
+    mpack_error_t error;  /* Error state */
+
+    #if MPACK_READ_TRACKING
+    mpack_track_t track; /* Stack of map/array/str/bin/ext reads */
+    #endif
+};
+
+/** @endcond */
+
+/**
+ * @name Lifecycle Functions
+ * @{
+ */
+
+/**
+ * Initializes an MPack reader with the given buffer. The reader does
+ * not assume ownership of the buffer, but the buffer must be writeable
+ * if a fill function will be used to refill it.
+ *
+ * @param reader The MPack reader.
+ * @param buffer The buffer with which to read MessagePack data.
+ * @param size The size of the buffer.
+ * @param count The number of bytes already in the buffer.
+ */
+void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count);
+
+/**
+ * Initializes an MPack reader directly into an error state. Use this if you
+ * are writing a wrapper to mpack_reader_init() which can fail its setup.
+ */
+void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error);
+
+/**
+ * Initializes an MPack reader to parse a pre-loaded contiguous chunk of data. The
+ * reader does not assume ownership of the data.
+ *
+ * @param reader The MPack reader.
+ * @param data The data to parse.
+ * @param count The number of bytes pointed to by data.
+ */
+void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count);
+
+#if MPACK_STDIO
+/**
+ * Initializes an MPack reader that reads from a file.
+ *
+ * The file will be automatically opened and closed by the reader.
+ */
+void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename);
+
+/**
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_reader_init_filename().
+ */
+MPACK_INLINE void mpack_reader_init_file(mpack_reader_t* reader, const char* filename) {
+    mpack_reader_init_filename(reader, filename);
+}
+
+/**
+ * Initializes an MPack reader that reads from a libc FILE. This can be used to
+ * read from stdin, or from a file opened separately.
+ *
+ * @param reader The MPack reader.
+ * @param stdfile The FILE.
+ * @param close_when_done If true, fclose() will be called on the FILE when it
+ *         is no longer needed. If false, the file will not be closed when
+ *         reading is done.
+ *
+ * @warning The reader is buffered. It will read data in advance of parsing it,
+ * and it may read more data than it parsed. See mpack_reader_remaining() to
+ * access the extra data.
+ */
+void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* stdfile, bool close_when_done);
+#endif
+
+/**
+ * @def mpack_reader_init_stack(reader)
+ * @hideinitializer
+ *
+ * Initializes an MPack reader using stack space as a buffer. A fill function
+ * should be added to the reader to fill the buffer.
+ *
+ * @see mpack_reader_set_fill
+ */
+
+/** @cond */
+#define mpack_reader_init_stack_line_ex(line, reader) \
+    char mpack_buf_##line[MPACK_STACK_SIZE]; \
+    mpack_reader_init((reader), mpack_buf_##line, sizeof(mpack_buf_##line), 0)
+
+#define mpack_reader_init_stack_line(line, reader) \
+    mpack_reader_init_stack_line_ex(line, reader)
+/** @endcond */
+
+#define mpack_reader_init_stack(reader) \
+    mpack_reader_init_stack_line(__LINE__, (reader))
+
+/**
+ * Cleans up the MPack reader, ensuring that all compound elements
+ * have been completely read. Returns the final error state of the
+ * reader.
+ *
+ * This will assert in tracking mode if the reader is not in an error
+ * state and has any incomplete reads. If you want to cancel reading
+ * in the middle of a document, you need to flag an error on the reader
+ * before destroying it (such as mpack_error_data).
+ *
+ * @see mpack_read_tag()
+ * @see mpack_reader_flag_error()
+ * @see mpack_error_data
+ */
+mpack_error_t mpack_reader_destroy(mpack_reader_t* reader);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Callbacks
+ * @{
+ */
+
+/**
+ * Sets the custom pointer to pass to the reader callbacks, such as fill
+ * or teardown.
+ *
+ * @param reader The MPack reader.
+ * @param context User data to pass to the reader callbacks.
+ *
+ * @see mpack_reader_context()
+ */
+MPACK_INLINE void mpack_reader_set_context(mpack_reader_t* reader, void* context) {
+    reader->context = context;
+}
+
+/**
+ * Returns the custom context for reader callbacks.
+ *
+ * @see mpack_reader_set_context
+ * @see mpack_reader_set_fill
+ * @see mpack_reader_set_skip
+ */
+MPACK_INLINE void* mpack_reader_context(mpack_reader_t* reader) {
+    return reader->context;
+}
+
+/**
+ * Sets the fill function to refill the data buffer when it runs out of data.
+ *
+ * If no fill function is used, truncated MessagePack data results in
+ * mpack_error_invalid (since the buffer is assumed to contain a
+ * complete MessagePack object.)
+ *
+ * If a fill function is used, truncated MessagePack data usually
+ * results in mpack_error_io (since the fill function fails to get
+ * the missing data.)
+ *
+ * This should normally be used with mpack_reader_set_context() to register
+ * a custom pointer to pass to the fill function.
+ *
+ * @param reader The MPack reader.
+ * @param fill The function to fetch additional data into the buffer.
+ */
+void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill);
+
+/**
+ * Sets the skip function to discard bytes from the source stream.
+ *
+ * It's not necessary to implement this function. If the stream is not
+ * seekable, don't set a skip callback. The reader will fall back to
+ * using the fill function instead.
+ *
+ * This should normally be used with mpack_reader_set_context() to register
+ * a custom pointer to pass to the skip function.
+ *
+ * The skip function is ignored in size-optimized builds to reduce code
+ * size. Data will be skipped with the fill function when necessary.
+ *
+ * @param reader The MPack reader.
+ * @param skip The function to discard bytes from the source stream.
+ */
+void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip);
+
+/**
+ * Sets the error function to call when an error is flagged on the reader.
+ *
+ * This should normally be used with mpack_reader_set_context() to register
+ * a custom pointer to pass to the error function.
+ *
+ * See the definition of mpack_reader_error_t for more information about
+ * what you can do from an error callback.
+ *
+ * @see mpack_reader_error_t
+ * @param reader The MPack reader.
+ * @param error_fn The function to call when an error is flagged on the reader.
+ */
+MPACK_INLINE void mpack_reader_set_error_handler(mpack_reader_t* reader, mpack_reader_error_t error_fn) {
+    reader->error_fn = error_fn;
+}
+
+/**
+ * Sets the teardown function to call when the reader is destroyed.
+ *
+ * This should normally be used with mpack_reader_set_context() to register
+ * a custom pointer to pass to the teardown function.
+ *
+ * @param reader The MPack reader.
+ * @param teardown The function to call when the reader is destroyed.
+ */
+MPACK_INLINE void mpack_reader_set_teardown(mpack_reader_t* reader, mpack_reader_teardown_t teardown) {
+    reader->teardown = teardown;
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Core Reader Functions
+ * @{
+ */
+
+/**
+ * Queries the error state of the MPack reader.
+ *
+ * If a reader is in an error state, you should discard all data since the
+ * last time the error flag was checked. The error flag cannot be cleared.
+ */
+MPACK_INLINE mpack_error_t mpack_reader_error(mpack_reader_t* reader) {
+    return reader->error;
+}
+
+/**
+ * Places the reader in the given error state, calling the error callback if one
+ * is set.
+ *
+ * This allows you to externally flag errors, for example if you are validating
+ * data as you read it.
+ *
+ * If the reader is already in an error state, this call is ignored and no
+ * error callback is called.
+ */
+void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error);
+
+/**
+ * Places the reader in the given error state if the given error is not mpack_ok,
+ * returning the resulting error state of the reader.
+ *
+ * This allows you to externally flag errors, for example if you are validating
+ * data as you read it.
+ *
+ * If the given error is mpack_ok or if the reader is already in an error state,
+ * this call is ignored and the actual error state of the reader is returned.
+ */
+MPACK_INLINE mpack_error_t mpack_reader_flag_if_error(mpack_reader_t* reader, mpack_error_t error) {
+    if (error != mpack_ok)
+        mpack_reader_flag_error(reader, error);
+    return mpack_reader_error(reader);
+}
+
+/**
+ * Returns bytes left in the reader's buffer.
+ *
+ * If you are done reading MessagePack data but there is other interesting data
+ * following it, the reader may have buffered too much data. The number of bytes
+ * remaining in the buffer and a pointer to the position of those bytes can be
+ * queried here.
+ *
+ * If you know the length of the MPack chunk beforehand, it's better to instead
+ * have your fill function limit the data it reads so that the reader does not
+ * have extra data. In this case you can simply check that this returns zero.
+ *
+ * Returns 0 if the reader is in an error state.
+ *
+ * @param reader The MPack reader from which to query remaining data.
+ * @param data [out] A pointer to the remaining data, or NULL.
+ * @return The number of bytes remaining in the buffer.
+ */
+size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data);
+
+/**
+ * Reads a MessagePack object header (an MPack tag.)
+ *
+ * If an error occurs, the reader is placed in an error state and a
+ * nil tag is returned. If the reader is already in an error state,
+ * a nil tag is returned.
+ *
+ * If the type is compound (i.e. is a map, array, string, binary or
+ * extension type), additional reads are required to get the contained
+ * data, and the corresponding done function must be called when done.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ * 
+ * @see mpack_read_bytes()
+ * @see mpack_done_array()
+ * @see mpack_done_map()
+ * @see mpack_done_str()
+ * @see mpack_done_bin()
+ * @see mpack_done_ext()
+ */
+mpack_tag_t mpack_read_tag(mpack_reader_t* reader);
+
+/**
+ * Parses the next MessagePack object header (an MPack tag) without
+ * advancing the reader.
+ *
+ * If an error occurs, the reader is placed in an error state and a
+ * nil tag is returned. If the reader is already in an error state,
+ * a nil tag is returned.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * @see mpack_read_tag()
+ * @see mpack_discard()
+ */
+mpack_tag_t mpack_peek_tag(mpack_reader_t* reader);
+
+/**
+ * @}
+ */
+
+/**
+ * @name String and Data Functions
+ * @{
+ */
+
+/**
+ * Skips bytes from the underlying stream. This is used only to
+ * skip the contents of a string, binary blob or extension object.
+ */
+void mpack_skip_bytes(mpack_reader_t* reader, size_t count);
+
+/**
+ * Reads bytes from a string, binary blob or extension object, copying
+ * them into the given buffer.
+ *
+ * A str, bin or ext must have been opened by a call to mpack_read_tag()
+ * which yielded one of these types, or by a call to an expect function
+ * such as mpack_expect_str() or mpack_expect_bin().
+ *
+ * If an error occurs, the buffer contents are undefined.
+ *
+ * This can be called multiple times for a single str, bin or ext
+ * to read the data in chunks. The total data read must add up
+ * to the size of the object.
+ *
+ * @param reader The MPack reader
+ * @param p The buffer in which to copy the bytes
+ * @param count The number of bytes to read
+ */
+void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count);
+
+/**
+ * Reads bytes from a string, ensures that the string is valid UTF-8,
+ * and copies the bytes into the given buffer.
+ *
+ * A string must have been opened by a call to mpack_read_tag() which
+ * yielded a string, or by a call to an expect function such as
+ * mpack_expect_str().
+ *
+ * The given byte count must match the complete size of the string as
+ * returned by the tag or expect function. You must ensure that the
+ * buffer fits the data.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * If an error occurs, the buffer contents are undefined.
+ *
+ * Unlike mpack_read_bytes(), this cannot be used to read the data in
+ * chunks (since this might split a character's UTF-8 bytes, and the
+ * reader does not keep track of the UTF-8 decoding state between reads.)
+ *
+ * @throws mpack_error_type if the string contains invalid UTF-8.
+ */
+void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count);
+
+/**
+ * Reads bytes from a string, ensures that the string contains no NUL
+ * bytes, copies the bytes into the given buffer and adds a null-terminator.
+ *
+ * A string must have been opened by a call to mpack_read_tag() which
+ * yielded a string, or by a call to an expect function such as
+ * mpack_expect_str().
+ *
+ * The given byte count must match the size of the string as returned
+ * by the tag or expect function. The string will only be copied if
+ * the buffer is large enough to store it.
+ *
+ * If an error occurs, the buffer will contain an empty string.
+ *
+ * @note If you know the object will be a string before reading it,
+ * it is highly recommended to use mpack_expect_cstr() instead.
+ * Alternatively you could use mpack_peek_tag() and call
+ * mpack_expect_cstr() if it's a string.
+ *
+ * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size
+ * @throws mpack_error_type if the string contains a null byte.
+ *
+ * @see mpack_peek_tag()
+ * @see mpack_expect_cstr()
+ * @see mpack_expect_utf8_cstr()
+ */
+void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count);
+
+/**
+ * Reads bytes from a string, ensures that the string is valid UTF-8
+ * with no NUL bytes, copies the bytes into the given buffer and adds a
+ * null-terminator.
+ *
+ * A string must have been opened by a call to mpack_read_tag() which
+ * yielded a string, or by a call to an expect function such as
+ * mpack_expect_str().
+ *
+ * The given byte count must match the size of the string as returned
+ * by the tag or expect function. The string will only be copied if
+ * the buffer is large enough to store it.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
+ * it cannot be represented in a null-terminated string.
+ *
+ * If an error occurs, the buffer will contain an empty string.
+ *
+ * @note If you know the object will be a string before reading it,
+ * it is highly recommended to use mpack_expect_utf8_cstr() instead.
+ * Alternatively you could use mpack_peek_tag() and call
+ * mpack_expect_utf8_cstr() if it's a string.
+ *
+ * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size
+ * @throws mpack_error_type if the string contains invalid UTF-8 or a null byte.
+ *
+ * @see mpack_peek_tag()
+ * @see mpack_expect_utf8_cstr()
+ */
+void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count);
+
+#ifdef MPACK_MALLOC
+/** @cond */
+// This can optionally add a null-terminator, but it does not check
+// whether the data contains null bytes. This must be done separately
+// in a cstring read function (possibly as part of a UTF-8 check.)
+char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated);
+/** @endcond */
+
+/**
+ * Reads bytes from a string, binary blob or extension object, allocating
+ * storage for them and returning the allocated pointer.
+ *
+ * The allocated string must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * Returns NULL if any error occurs, or if count is zero.
+ */
+MPACK_INLINE char* mpack_read_bytes_alloc(mpack_reader_t* reader, size_t count) {
+    return mpack_read_bytes_alloc_impl(reader, count, false);
+}
+#endif
+
+/**
+ * Reads bytes from a string, binary blob or extension object in-place in
+ * the buffer. This can be used to avoid copying the data.
+ *
+ * A str, bin or ext must have been opened by a call to mpack_read_tag()
+ * which yielded one of these types, or by a call to an expect function
+ * such as mpack_expect_str() or mpack_expect_bin().
+ *
+ * If the bytes are from a string, the string is not null-terminated! Use
+ * mpack_read_cstr() to copy the string into a buffer and add a null-terminator.
+ *
+ * The returned pointer is invalidated on the next read, or when the buffer
+ * is destroyed.
+ *
+ * The reader will move data around in the buffer if needed to ensure that
+ * the pointer can always be returned, so this should only be used if
+ * count is very small compared to the buffer size. If you need to check
+ * whether a small size is reasonable (for example you intend to handle small and
+ * large sizes differently), you can call mpack_should_read_bytes_inplace().
+ *
+ * This can be called multiple times for a single str, bin or ext
+ * to read the data in chunks. The total data read must add up
+ * to the size of the object.
+ *
+ * NULL is returned if the reader is in an error state.
+ *
+ * @throws mpack_error_too_big if the requested size is larger than the buffer size
+ *
+ * @see mpack_should_read_bytes_inplace()
+ */
+const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count);
+
+/**
+ * Reads bytes from a string in-place in the buffer and ensures they are
+ * valid UTF-8. This can be used to avoid copying the data.
+ *
+ * A string must have been opened by a call to mpack_read_tag() which
+ * yielded a string, or by a call to an expect function such as
+ * mpack_expect_str().
+ *
+ * The string is not null-terminated! Use mpack_read_utf8_cstr() to
+ * copy the string into a buffer and add a null-terminator.
+ *
+ * The returned pointer is invalidated on the next read, or when the buffer
+ * is destroyed.
+ *
+ * The reader will move data around in the buffer if needed to ensure that
+ * the pointer can always be returned, so this should only be used if
+ * count is very small compared to the buffer size. If you need to check
+ * whether a small size is reasonable (for example you intend to handle small and
+ * large sizes differently), you can call mpack_should_read_bytes_inplace().
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * Unlike mpack_read_bytes_inplace(), this cannot be used to read the data in
+ * chunks (since this might split a character's UTF-8 bytes, and the
+ * reader does not keep track of the UTF-8 decoding state between reads.)
+ *
+ * NULL is returned if the reader is in an error state.
+ *
+ * @throws mpack_error_type if the string contains invalid UTF-8
+ * @throws mpack_error_too_big if the requested size is larger than the buffer size
+ *
+ * @see mpack_should_read_bytes_inplace()
+ */
+const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count);
+
+/**
+ * Returns true if it's a good idea to read the given number of bytes
+ * in-place.
+ *
+ * If the read will be larger than some small fraction of the buffer size,
+ * this will return false to avoid shuffling too much data back and forth
+ * in the buffer.
+ *
+ * Use this if you're expecting arbitrary size data, and you want to read
+ * in-place for the best performance when possible but will fall back to
+ * a normal read if the data is too large.
+ *
+ * @see mpack_read_bytes_inplace()
+ */
+MPACK_INLINE bool mpack_should_read_bytes_inplace(mpack_reader_t* reader, size_t count) {
+    return (reader->size == 0 || count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR);
+}
+
+#if MPACK_EXTENSIONS
+/**
+ * Reads a timestamp contained in an ext object of the given size, closing the
+ * ext type.
+ *
+ * An ext object of exttype @ref MPACK_EXTTYPE_TIMESTAMP must have been opened
+ * by a call to e.g. mpack_read_tag() or mpack_expect_ext().
+ *
+ * You must NOT call mpack_done_ext() after calling this. A timestamp ext
+ * object can only contain a single timestamp value, so this calls
+ * mpack_done_ext() automatically.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @throws mpack_error_invalid if the size is not one of the supported
+ * timestamp sizes, or if the nanoseconds are out of range.
+ */
+mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Core Reader Functions
+ * @{
+ */
+
+#if MPACK_READ_TRACKING
+/**
+ * Finishes reading the given type.
+ *
+ * This will track reads to ensure that the correct number of elements
+ * or bytes are read.
+ */
+void mpack_done_type(mpack_reader_t* reader, mpack_type_t type);
+#else
+MPACK_INLINE void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) {
+    MPACK_UNUSED(reader);
+    MPACK_UNUSED(type);
+}
+#endif
+
+/**
+ * Finishes reading an array.
+ *
+ * This will track reads to ensure that the correct number of elements are read.
+ */
+MPACK_INLINE void mpack_done_array(mpack_reader_t* reader) {
+    mpack_done_type(reader, mpack_type_array);
+}
+
+/**
+ * @fn mpack_done_map(mpack_reader_t* reader)
+ *
+ * Finishes reading a map.
+ *
+ * This will track reads to ensure that the correct number of elements are read.
+ */
+MPACK_INLINE void mpack_done_map(mpack_reader_t* reader) {
+    mpack_done_type(reader, mpack_type_map);
+}
+
+/**
+ * @fn mpack_done_str(mpack_reader_t* reader)
+ *
+ * Finishes reading a string.
+ *
+ * This will track reads to ensure that the correct number of bytes are read.
+ */
+MPACK_INLINE void mpack_done_str(mpack_reader_t* reader) {
+    mpack_done_type(reader, mpack_type_str);
+}
+
+/**
+ * @fn mpack_done_bin(mpack_reader_t* reader)
+ *
+ * Finishes reading a binary data blob.
+ *
+ * This will track reads to ensure that the correct number of bytes are read.
+ */
+MPACK_INLINE void mpack_done_bin(mpack_reader_t* reader) {
+    mpack_done_type(reader, mpack_type_bin);
+}
+
+#if MPACK_EXTENSIONS
+/**
+ * @fn mpack_done_ext(mpack_reader_t* reader)
+ *
+ * Finishes reading an extended type binary data blob.
+ *
+ * This will track reads to ensure that the correct number of bytes are read.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+MPACK_INLINE void mpack_done_ext(mpack_reader_t* reader) {
+    mpack_done_type(reader, mpack_type_ext);
+}
+#endif
+
+/**
+ * Reads and discards the next object. This will read and discard all
+ * contained data as well if it is a compound type.
+ */
+void mpack_discard(mpack_reader_t* reader);
+
+/**
+ * @}
+ */
+
+/** @cond */
+
+#if MPACK_DEBUG && MPACK_STDIO
+/**
+ * @name Debugging Functions
+ * @{
+ */
+/*
+ * Converts a blob of MessagePack to a pseudo-JSON string for debugging
+ * purposes, placing the result in the given buffer with a null-terminator.
+ *
+ * If the buffer does not have enough space, the result will be truncated (but
+ * it is guaranteed to be null-terminated.)
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size);
+
+/*
+ * Converts a node to pseudo-JSON for debugging purposes, calling the given
+ * callback as many times as is necessary to output the character data.
+ *
+ * No null-terminator or trailing newline will be written.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context);
+
+/*
+ * Converts a blob of MessagePack to pseudo-JSON for debugging purposes
+ * and pretty-prints it to the given file.
+ */
+void mpack_print_data_to_file(const char* data, size_t len, FILE* file);
+
+/*
+ * Converts a blob of MessagePack to pseudo-JSON for debugging purposes
+ * and pretty-prints it to stdout.
+ */
+MPACK_INLINE void mpack_print_data_to_stdout(const char* data, size_t len) {
+    mpack_print_data_to_file(data, len, stdout);
+}
+
+/*
+ * Converts the MessagePack contained in the given `FILE*` to pseudo-JSON for
+ * debugging purposes, calling the given callback as many times as is necessary
+ * to output the character data.
+ */
+void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context);
+
+/*
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_print_data_to_stdout().
+ */
+MPACK_INLINE void mpack_print(const char* data, size_t len) {
+    mpack_print_data_to_stdout(data, len);
+}
+
+/**
+ * @}
+ */
+#endif
+
+/** @endcond */
+
+/**
+ * @}
+ */
+
+
+
+#if MPACK_INTERNAL
+
+bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count);
+
+/*
+ * Ensures there are at least @c count bytes left in the
+ * data, raising an error and returning false if more
+ * data cannot be made available.
+ */
+MPACK_INLINE bool mpack_reader_ensure(mpack_reader_t* reader, size_t count) {
+    mpack_assert(count != 0, "cannot ensure zero bytes!");
+    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
+
+    if (count <= (size_t)(reader->end - reader->data))
+        return true;
+    return mpack_reader_ensure_straddle(reader, count);
+}
+
+void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count);
+
+// Reads count bytes into p, deferring to mpack_read_native_straddle() if more
+// bytes are needed than are available in the buffer.
+MPACK_INLINE void mpack_read_native(mpack_reader_t* reader, char* p, size_t count) {
+    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
+
+    if (count > (size_t)(reader->end - reader->data)) {
+        mpack_read_native_straddle(reader, p, count);
+    } else {
+        mpack_memcpy(p, reader->data, count);
+        reader->data += count;
+    }
+}
+
+#if MPACK_READ_TRACKING
+#define MPACK_READER_TRACK(reader, error_expr) \
+    (((reader)->error == mpack_ok) ? mpack_reader_flag_if_error((reader), (error_expr)) : (reader)->error)
+#else
+#define MPACK_READER_TRACK(reader, error_expr) (MPACK_UNUSED(reader), mpack_ok)
+#endif
+
+MPACK_INLINE mpack_error_t mpack_reader_track_element(mpack_reader_t* reader) {
+    return MPACK_READER_TRACK(reader, mpack_track_element(&reader->track, true));
+}
+
+MPACK_INLINE mpack_error_t mpack_reader_track_peek_element(mpack_reader_t* reader) {
+    return MPACK_READER_TRACK(reader, mpack_track_peek_element(&reader->track, true));
+}
+
+MPACK_INLINE mpack_error_t mpack_reader_track_bytes(mpack_reader_t* reader, size_t count) {
+    MPACK_UNUSED(count);
+    return MPACK_READER_TRACK(reader, mpack_track_bytes(&reader->track, true, count));
+}
+
+MPACK_INLINE mpack_error_t mpack_reader_track_str_bytes_all(mpack_reader_t* reader, size_t count) {
+    MPACK_UNUSED(count);
+    return MPACK_READER_TRACK(reader, mpack_track_str_bytes_all(&reader->track, true, count));
+}
+
+#endif
+
+
+
+#endif
+
+MPACK_EXTERN_C_END
+MPACK_HEADER_END
+
+#endif
+
+
+/* mpack/mpack-expect.h.h */
+
+/**
+ * @file
+ *
+ * Declares the MPack static Expect API.
+ */
+
+#ifndef MPACK_EXPECT_H
+#define MPACK_EXPECT_H 1
+
+/* #include "mpack-reader.h" */
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+#if MPACK_EXPECT
+
+#if !MPACK_READER
+#error "MPACK_EXPECT requires MPACK_READER."
+#endif
+
+/**
+ * @defgroup expect Expect API
+ *
+ * The MPack Expect API allows you to easily read MessagePack data when you
+ * expect it to follow a predefined schema.
+ *
+ * @note If you are not writing code for an embedded device (or otherwise do
+ * not need maximum performance with minimal memory usage), you should not use
+ * this. You probably want to use the @link node Node API@endlink instead.
+ *
+ * See @ref docs/expect.md for examples.
+ *
+ * The main purpose of the Expect API is convenience, so the API is lax. It
+ * automatically converts between similar types where there is no loss of
+ * precision.
+ *
+ * When using any of the expect functions, if the type or value of what was
+ * read does not match what is expected, @ref mpack_error_type is raised.
+ *
+ * @{
+ */
+
+/**
+ * @name Basic Number Functions
+ * @{
+ */
+
+/**
+ * Reads an 8-bit unsigned integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit unsigned int.
+ *
+ * Returns zero if an error occurs.
+ */
+uint8_t mpack_expect_u8(mpack_reader_t* reader);
+
+/**
+ * Reads a 16-bit unsigned integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit unsigned int.
+ *
+ * Returns zero if an error occurs.
+ */
+uint16_t mpack_expect_u16(mpack_reader_t* reader);
+
+/**
+ * Reads a 32-bit unsigned integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit unsigned int.
+ *
+ * Returns zero if an error occurs.
+ */
+uint32_t mpack_expect_u32(mpack_reader_t* reader);
+
+/**
+ * Reads a 64-bit unsigned integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit unsigned int.
+ *
+ * Returns zero if an error occurs.
+ */
+uint64_t mpack_expect_u64(mpack_reader_t* reader);
+
+/**
+ * Reads an 8-bit signed integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit signed int.
+ *
+ * Returns zero if an error occurs.
+ */
+int8_t mpack_expect_i8(mpack_reader_t* reader);
+
+/**
+ * Reads a 16-bit signed integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit signed int.
+ *
+ * Returns zero if an error occurs.
+ */
+int16_t mpack_expect_i16(mpack_reader_t* reader);
+
+/**
+ * Reads a 32-bit signed integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit signed int.
+ *
+ * Returns zero if an error occurs.
+ */
+int32_t mpack_expect_i32(mpack_reader_t* reader);
+
+/**
+ * Reads a 64-bit signed integer.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit signed int.
+ *
+ * Returns zero if an error occurs.
+ */
+int64_t mpack_expect_i64(mpack_reader_t* reader);
+
+/**
+ * Reads a number, returning the value as a float. The underlying value can be an
+ * integer, float or double; the value is converted to a float.
+ *
+ * @note Reading a double or a large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+float mpack_expect_float(mpack_reader_t* reader);
+
+/**
+ * Reads a number, returning the value as a double. The underlying value can be an
+ * integer, float or double; the value is converted to a double.
+ *
+ * @note Reading a very large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+double mpack_expect_double(mpack_reader_t* reader);
+
+/**
+ * Reads a float. The underlying value must be a float, not a double or an integer.
+ * This ensures no loss of precision can occur.
+ *
+ * @throws mpack_error_type if the underlying value is not a float.
+ */
+float mpack_expect_float_strict(mpack_reader_t* reader);
+
+/**
+ * Reads a double. The underlying value must be a float or double, not an integer.
+ * This ensures no loss of precision can occur.
+ *
+ * @throws mpack_error_type if the underlying value is not a float or double.
+ */
+double mpack_expect_double_strict(mpack_reader_t* reader);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Ranged Number Functions
+ * @{
+ */
+
+/**
+ * Reads an 8-bit unsigned integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit unsigned int.
+ *
+ * Returns min_value if an error occurs.
+ */
+uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value);
+
+/**
+ * Reads a 16-bit unsigned integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit unsigned int.
+ *
+ * Returns min_value if an error occurs.
+ */
+uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value);
+
+/**
+ * Reads a 32-bit unsigned integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit unsigned int.
+ *
+ * Returns min_value if an error occurs.
+ */
+uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value);
+
+/**
+ * Reads a 64-bit unsigned integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit unsigned int.
+ *
+ * Returns min_value if an error occurs.
+ */
+uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value);
+
+/**
+ * Reads an unsigned integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an unsigned int.
+ *
+ * Returns min_value if an error occurs.
+ */
+MPACK_INLINE unsigned int mpack_expect_uint_range(mpack_reader_t* reader, unsigned int min_value, unsigned int max_value) {
+    // This should be true at compile-time, so this just wraps the 32-bit
+    // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4.
+    if (sizeof(unsigned int) == 4)
+        return (unsigned int)mpack_expect_u32_range(reader, (uint32_t)min_value, (uint32_t)max_value);
+    return (unsigned int)mpack_expect_u64_range(reader, min_value, max_value);
+}
+
+/**
+ * Reads an 8-bit unsigned integer, ensuring that it is at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit unsigned int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE uint8_t mpack_expect_u8_max(mpack_reader_t* reader, uint8_t max_value) {
+    return mpack_expect_u8_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 16-bit unsigned integer, ensuring that it is at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit unsigned int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE uint16_t mpack_expect_u16_max(mpack_reader_t* reader, uint16_t max_value) {
+    return mpack_expect_u16_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 32-bit unsigned integer, ensuring that it is at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit unsigned int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE uint32_t mpack_expect_u32_max(mpack_reader_t* reader, uint32_t max_value) {
+    return mpack_expect_u32_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 64-bit unsigned integer, ensuring that it is at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit unsigned int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE uint64_t mpack_expect_u64_max(mpack_reader_t* reader, uint64_t max_value) {
+    return mpack_expect_u64_range(reader, 0, max_value);
+}
+
+/**
+ * Reads an unsigned integer, ensuring that it is at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an unsigned int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE unsigned int mpack_expect_uint_max(mpack_reader_t* reader, unsigned int max_value) {
+    return mpack_expect_uint_range(reader, 0, max_value);
+}
+
+/**
+ * Reads an 8-bit signed integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit signed int.
+ *
+ * Returns min_value if an error occurs.
+ */
+int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value);
+
+/**
+ * Reads a 16-bit signed integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit signed int.
+ *
+ * Returns min_value if an error occurs.
+ */
+int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value);
+
+/**
+ * Reads a 32-bit signed integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit signed int.
+ *
+ * Returns min_value if an error occurs.
+ */
+int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value);
+
+/**
+ * Reads a 64-bit signed integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit signed int.
+ *
+ * Returns min_value if an error occurs.
+ */
+int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value);
+
+/**
+ * Reads a signed integer, ensuring that it falls within the given range.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a signed int.
+ *
+ * Returns min_value if an error occurs.
+ */
+MPACK_INLINE int mpack_expect_int_range(mpack_reader_t* reader, int min_value, int max_value) {
+    // This should be true at compile-time, so this just wraps the 32-bit
+    // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4.
+    if (sizeof(int) == 4)
+        return (int)mpack_expect_i32_range(reader, (int32_t)min_value, (int32_t)max_value);
+    return (int)mpack_expect_i64_range(reader, min_value, max_value);
+}
+
+/**
+ * Reads an 8-bit signed integer, ensuring that it is at least zero and at
+ * most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an 8-bit signed int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE int8_t mpack_expect_i8_max(mpack_reader_t* reader, int8_t max_value) {
+    return mpack_expect_i8_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 16-bit signed integer, ensuring that it is at least zero and at
+ * most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 16-bit signed int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE int16_t mpack_expect_i16_max(mpack_reader_t* reader, int16_t max_value) {
+    return mpack_expect_i16_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 32-bit signed integer, ensuring that it is at least zero and at
+ * most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 32-bit signed int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE int32_t mpack_expect_i32_max(mpack_reader_t* reader, int32_t max_value) {
+    return mpack_expect_i32_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a 64-bit signed integer, ensuring that it is at least zero and at
+ * most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a 64-bit signed int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE int64_t mpack_expect_i64_max(mpack_reader_t* reader, int64_t max_value) {
+    return mpack_expect_i64_range(reader, 0, max_value);
+}
+
+/**
+ * Reads an int, ensuring that it is at least zero and at most @a max_value.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a signed int.
+ *
+ * Returns 0 if an error occurs.
+ */
+MPACK_INLINE int mpack_expect_int_max(mpack_reader_t* reader, int max_value) {
+    return mpack_expect_int_range(reader, 0, max_value);
+}
+
+/**
+ * Reads a number, ensuring that it falls within the given range and returning
+ * the value as a float. The underlying value can be an integer, float or
+ * double; the value is converted to a float.
+ *
+ * @note Reading a double or a large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value);
+
+/**
+ * Reads a number, ensuring that it falls within the given range and returning
+ * the value as a double. The underlying value can be an integer, float or
+ * double; the value is converted to a double.
+ *
+ * @note Reading a very large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value);
+
+/**
+ * @}
+ */
+
+
+
+// These are additional Basic Number functions that wrap inline range functions.
+
+/**
+ * @name Basic Number Functions
+ * @{
+ */
+
+/**
+ * Reads an unsigned int.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in an unsigned int.
+ *
+ * Returns zero if an error occurs.
+ */
+MPACK_INLINE unsigned int mpack_expect_uint(mpack_reader_t* reader) {
+
+    // This should be true at compile-time, so this just wraps the 32-bit function.
+    if (sizeof(unsigned int) == 4)
+        return (unsigned int)mpack_expect_u32(reader);
+
+    // Otherwise we wrap the max function to ensure it fits.
+    return (unsigned int)mpack_expect_u64_max(reader, UINT_MAX);
+
+}
+
+/**
+ * Reads a signed int.
+ *
+ * The underlying type may be an integer type of any size and signedness,
+ * as long as the value can be represented in a signed int.
+ *
+ * Returns zero if an error occurs.
+ */
+MPACK_INLINE int mpack_expect_int(mpack_reader_t* reader) {
+
+    // This should be true at compile-time, so this just wraps the 32-bit function.
+    if (sizeof(int) == 4)
+        return (int)mpack_expect_i32(reader);
+
+    // Otherwise we wrap the range function to ensure it fits.
+    return (int)mpack_expect_i64_range(reader, INT_MIN, INT_MAX);
+
+}
+
+/**
+ * @}
+ */
+
+
+
+/**
+ * @name Matching Number Functions
+ * @{
+ */
+
+/**
+ * Reads an unsigned integer, ensuring that it exactly matches the given value.
+ *
+ * mpack_error_type is raised if the value is not representable as an unsigned
+ * integer or if it does not exactly match the given value.
+ */
+void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value);
+
+/**
+ * Reads a signed integer, ensuring that it exactly matches the given value.
+ *
+ * mpack_error_type is raised if the value is not representable as a signed
+ * integer or if it does not exactly match the given value.
+ */
+void mpack_expect_int_match(mpack_reader_t* reader, int64_t value);
+
+/**
+ * @name Other Basic Types
+ * @{
+ */
+
+/**
+ * Reads a nil, raising @ref mpack_error_type if the value is not nil.
+ */
+void mpack_expect_nil(mpack_reader_t* reader);
+
+/**
+ * Reads a boolean.
+ *
+ * @note Integers will raise mpack_error_type; the value must be strictly a boolean.
+ */
+bool mpack_expect_bool(mpack_reader_t* reader);
+
+/**
+ * Reads a boolean, raising @ref mpack_error_type if its value is not @c true.
+ */
+void mpack_expect_true(mpack_reader_t* reader);
+
+/**
+ * Reads a boolean, raising @ref mpack_error_type if its value is not @c false.
+ */
+void mpack_expect_false(mpack_reader_t* reader);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Extension Functions
+ * @{
+ */
+
+#if MPACK_EXTENSIONS
+/**
+ * Reads a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader);
+
+/**
+ * Reads a timestamp in seconds, truncating the nanoseconds (if any).
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Compound Types
+ * @{
+ */
+
+/**
+ * Reads the start of a map, returning its element count.
+ *
+ * A number of values follow equal to twice the element count of the map,
+ * alternating between keys and values. @ref mpack_done_map() must be called
+ * once all elements have been read.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * @warning This call is dangerous! It does not have a size limit, and it
+ * does not have any way of checking whether there is enough data in the
+ * message (since the data could be coming from a stream.) When looping
+ * through the map's contents, you must check for errors on each iteration
+ * of the loop. Otherwise an attacker could craft a message declaring a map
+ * of a billion elements which would throw your parsing code into an
+ * infinite loop! You should strongly consider using mpack_expect_map_max()
+ * with a safe maximum size instead.
+ *
+ * @throws mpack_error_type if the value is not a map.
+ */
+uint32_t mpack_expect_map(mpack_reader_t* reader);
+
+/**
+ * Reads the start of a map with a number of elements in the given range, returning
+ * its element count.
+ *
+ * A number of values follow equal to twice the element count of the map,
+ * alternating between keys and values. @ref mpack_done_map() must be called
+ * once all elements have been read.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * min_count is returned if an error occurs.
+ *
+ * @throws mpack_error_type if the value is not a map or if its size does
+ * not fall within the given range.
+ */
+uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count);
+
+/**
+ * Reads the start of a map with a number of elements at most @a max_count,
+ * returning its element count.
+ *
+ * A number of values follow equal to twice the element count of the map,
+ * alternating between keys and values. @ref mpack_done_map() must be called
+ * once all elements have been read.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * Zero is returned if an error occurs.
+ *
+ * @throws mpack_error_type if the value is not a map or if its size is
+ * greater than max_count.
+ */
+MPACK_INLINE uint32_t mpack_expect_map_max(mpack_reader_t* reader, uint32_t max_count) {
+    return mpack_expect_map_range(reader, 0, max_count);
+}
+
+/**
+ * Reads the start of a map of the exact size given.
+ *
+ * A number of values follow equal to twice the element count of the map,
+ * alternating between keys and values. @ref mpack_done_map() must be called
+ * once all elements have been read.
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * @throws mpack_error_type if the value is not a map or if its size
+ * does not match the given count.
+ */
+void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count);
+
+/**
+ * Reads a nil node or the start of a map, returning whether a map was
+ * read and placing its number of key/value pairs in count.
+ *
+ * If a map was read, a number of values follow equal to twice the element count
+ * of the map, alternating between keys and values. @ref mpack_done_map() should
+ * also be called once all elements have been read (only if a map was read.)
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON.
+ *
+ * @warning This call is dangerous! It does not have a size limit, and it
+ * does not have any way of checking whether there is enough data in the
+ * message (since the data could be coming from a stream.) When looping
+ * through the map's contents, you must check for errors on each iteration
+ * of the loop. Otherwise an attacker could craft a message declaring a map
+ * of a billion elements which would throw your parsing code into an
+ * infinite loop! You should strongly consider using mpack_expect_map_max_or_nil()
+ * with a safe maximum size instead.
+ *
+ * @returns @c true if a map was read successfully; @c false if nil was read
+ *     or an error occurred.
+ * @throws mpack_error_type if the value is not a nil or map.
+ */
+bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count);
+
+/**
+ * Reads a nil node or the start of a map with a number of elements at most
+ * max_count, returning whether a map was read and placing its number of
+ * key/value pairs in count.
+ *
+ * If a map was read, a number of values follow equal to twice the element count
+ * of the map, alternating between keys and values. @ref mpack_done_map() should
+ * anlso be called once all elements have been read (only if a map was read.)
+ *
+ * @note Maps in JSON are unordered, so it is recommended not to expect
+ * a specific ordering for your map values in case your data is converted
+ * to/from JSON. Consider using mpack_expect_key_cstr() or mpack_expect_key_uint()
+ * to switch on the key; see @ref docs/expect.md for examples.
+ *
+ * @returns @c true if a map was read successfully; @c false if nil was read
+ *     or an error occurred.
+ * @throws mpack_error_type if the value is not a nil or map.
+ */
+bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count);
+
+/**
+ * Reads the start of an array, returning its element count.
+ *
+ * A number of values follow equal to the element count of the array.
+ * @ref mpack_done_array() must be called once all elements have been read.
+ *
+ * @warning This call is dangerous! It does not have a size limit, and it
+ * does not have any way of checking whether there is enough data in the
+ * message (since the data could be coming from a stream.) When looping
+ * through the array's contents, you must check for errors on each iteration
+ * of the loop. Otherwise an attacker could craft a message declaring an array
+ * of a billion elements which would throw your parsing code into an
+ * infinite loop! You should strongly consider using mpack_expect_array_max()
+ * with a safe maximum size instead.
+ */
+uint32_t mpack_expect_array(mpack_reader_t* reader);
+
+/**
+ * Reads the start of an array with a number of elements in the given range,
+ * returning its element count.
+ *
+ * A number of values follow equal to the element count of the array.
+ * @ref mpack_done_array() must be called once all elements have been read.
+ *
+ * min_count is returned if an error occurs.
+ *
+ * @throws mpack_error_type if the value is not an array or if its size does
+ * not fall within the given range.
+ */
+uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count);
+
+/**
+ * Reads the start of an array with a number of elements at most @a max_count,
+ * returning its element count.
+ *
+ * A number of values follow equal to the element count of the array.
+ * @ref mpack_done_array() must be called once all elements have been read.
+ *
+ * Zero is returned if an error occurs.
+ *
+ * @throws mpack_error_type if the value is not an array or if its size is
+ * greater than max_count.
+ */
+MPACK_INLINE uint32_t mpack_expect_array_max(mpack_reader_t* reader, uint32_t max_count) {
+    return mpack_expect_array_range(reader, 0, max_count);
+}
+
+/**
+ * Reads the start of an array of the exact size given.
+ *
+ * A number of values follow equal to the element count of the array.
+ * @ref mpack_done_array() must be called once all elements have been read.
+ *
+ * @throws mpack_error_type if the value is not an array or if its size does
+ * not match the given count.
+ */
+void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count);
+
+/**
+ * Reads a nil node or the start of an array, returning whether an array was
+ * read and placing its number of elements in count.
+ *
+ * If an array was read, a number of values follow equal to the element count
+ * of the array. @ref mpack_done_array() should also be called once all elements
+ * have been read (only if an array was read.)
+ *
+ * @warning This call is dangerous! It does not have a size limit, and it
+ * does not have any way of checking whether there is enough data in the
+ * message (since the data could be coming from a stream.) When looping
+ * through the array's contents, you must check for errors on each iteration
+ * of the loop. Otherwise an attacker could craft a message declaring an array
+ * of a billion elements which would throw your parsing code into an
+ * infinite loop! You should strongly consider using mpack_expect_array_max_or_nil()
+ * with a safe maximum size instead.
+ *
+ * @returns @c true if an array was read successfully; @c false if nil was read
+ *     or an error occurred.
+ * @throws mpack_error_type if the value is not a nil or array.
+ */
+bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count);
+
+/**
+ * Reads a nil node or the start of an array with a number of elements at most
+ * max_count, returning whether an array was read and placing its number of
+ * key/value pairs in count.
+ *
+ * If an array was read, a number of values follow equal to the element count
+ * of the array. @ref mpack_done_array() should also be called once all elements
+ * have been read (only if an array was read.)
+ *
+ * @returns @c true if an array was read successfully; @c false if nil was read
+ *     or an error occurred.
+ * @throws mpack_error_type if the value is not a nil or array.
+ */
+bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count);
+
+#ifdef MPACK_MALLOC
+/**
+ * @hideinitializer
+ *
+ * Reads the start of an array and allocates storage for it, placing its
+ * size in out_count. A number of objects follow equal to the element count
+ * of the array. You must call @ref mpack_done_array() when done (even
+ * if the element count is zero.)
+ *
+ * If an error occurs, NULL is returned and the reader is placed in an
+ * error state.
+ *
+ * If the count is zero, NULL is returned. This does not indicate error.
+ * You should not check the return value for NULL to check for errors; only
+ * check the reader's error state.
+ *
+ * The allocated array must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_type if the value is not an array or if its size is
+ * greater than max_count.
+ */
+#define mpack_expect_array_alloc(reader, Type, max_count, out_count) \
+    ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, false))
+
+/**
+ * @hideinitializer
+ *
+ * Reads a nil node or the start of an array and allocates storage for it,
+ * placing its size in out_count. A number of objects follow equal to the element
+ * count of the array if a non-empty array was read.
+ *
+ * If an error occurs, NULL is returned and the reader is placed in an
+ * error state.
+ *
+ * If a nil node was read, NULL is returned. If an empty array was read,
+ * mpack_done_array() is called automatically and NULL is returned. These
+ * do not indicate error. You should not check the return value for NULL
+ * to check for errors; only check the reader's error state.
+ *
+ * The allocated array must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @warning You must call @ref mpack_done_array() if and only if a non-zero
+ * element count is read. This function does not differentiate between nil
+ * and an empty array.
+ *
+ * @throws mpack_error_type if the value is not an array or if its size is
+ * greater than max_count.
+ */
+#define mpack_expect_array_or_nil_alloc(reader, Type, max_count, out_count) \
+    ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, true))
+#endif
+
+/**
+ * @}
+ */
+
+/** @cond */
+#ifdef MPACK_MALLOC
+void* mpack_expect_array_alloc_impl(mpack_reader_t* reader,
+        size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil);
+#endif
+/** @endcond */
+
+
+/**
+ * @name String Functions
+ * @{
+ */
+
+/**
+ * Reads the start of a string, returning its size in bytes.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). mpack_done_str() must be called
+ * once all bytes have been read.
+ *
+ * NUL bytes are allowed in the string, and no encoding checks are done.
+ *
+ * mpack_error_type is raised if the value is not a string.
+ */
+uint32_t mpack_expect_str(mpack_reader_t* reader);
+
+/**
+ * Reads a string of at most the given size, writing it into the
+ * given buffer and returning its size in bytes.
+ *
+ * This does not add a null-terminator! Use mpack_expect_cstr() to
+ * add a null-terminator.
+ *
+ * NUL bytes are allowed in the string, and no encoding checks are done.
+ */
+size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize);
+
+/**
+ * Reads a string into the given buffer, ensuring it is a valid UTF-8 string
+ * and returning its size in bytes.
+ *
+ * This does not add a null-terminator! Use mpack_expect_utf8_cstr() to
+ * add a null-terminator.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed.
+ *
+ * NUL bytes are allowed in the string (as they are in UTF-8.)
+ *
+ * Raises mpack_error_too_big if there is not enough room for the string.
+ * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string.
+ */
+size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t bufsize);
+
+/**
+ * Reads the start of a string, raising an error if its length is not
+ * at most the given number of bytes (not including any null-terminator.)
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called
+ * once all bytes have been read.
+ *
+ * @throws mpack_error_type If the value is not a string.
+ * @throws mpack_error_too_big If the string's length in bytes is larger than the given maximum size.
+ */
+MPACK_INLINE uint32_t mpack_expect_str_max(mpack_reader_t* reader, uint32_t maxsize) {
+    uint32_t length = mpack_expect_str(reader);
+    if (length > maxsize) {
+        mpack_reader_flag_error(reader, mpack_error_too_big);
+        return 0;
+    }
+    return length;
+}
+
+/**
+ * Reads the start of a string, raising an error if its length is not
+ * exactly the given number of bytes (not including any null-terminator.)
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called
+ * once all bytes have been read.
+ *
+ * mpack_error_type is raised if the value is not a string or if its
+ * length does not match.
+ */
+MPACK_INLINE void mpack_expect_str_length(mpack_reader_t* reader, uint32_t count) {
+    if (mpack_expect_str(reader) != count)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+/**
+ * Reads a string, ensuring it exactly matches the given string.
+ *
+ * Remember that maps are unordered in JSON. Don't use this for map keys
+ * unless the map has only a single key!
+ */
+void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t length);
+
+/**
+ * Reads a string into the given buffer, ensures it has no null bytes,
+ * and adds a null-terminator at the end.
+ *
+ * Raises mpack_error_too_big if there is not enough room for the string and null-terminator.
+ * Raises mpack_error_type if the value is not a string or contains a null byte.
+ */
+void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t size);
+
+/**
+ * Reads a string into the given buffer, ensures it is a valid UTF-8 string
+ * without NUL characters, and adds a null-terminator at the end.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
+ * it cannot be represented in a null-terminated string.
+ *
+ * Raises mpack_error_too_big if there is not enough room for the string and null-terminator.
+ * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string.
+ */
+void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t size);
+
+#ifdef MPACK_MALLOC
+/**
+ * Reads a string with the given total maximum size (including space for a
+ * null-terminator), allocates storage for it, ensures it has no null-bytes,
+ * and adds a null-terminator at the end. You assume ownership of the
+ * returned pointer if reading succeeds.
+ *
+ * The allocated string must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_too_big If the string plus null-terminator is larger than the given maxsize.
+ * @throws mpack_error_type If the value is not a string or contains a null byte.
+ */
+char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize);
+
+/**
+ * Reads a string with the given total maximum size (including space for a
+ * null-terminator), allocates storage for it, ensures it is valid UTF-8
+ * with no null-bytes, and adds a null-terminator at the end. You assume
+ * ownership of the returned pointer if reading succeeds.
+ *
+ * The length in bytes of the string, not including the null-terminator,
+ * will be written to size.
+ *
+ * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
+ * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
+ * it cannot be represented in a null-terminated string.
+ *
+ * The allocated string must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ * if you want a null-terminator.
+ *
+ * @throws mpack_error_too_big If the string plus null-terminator is larger
+ *     than the given maxsize.
+ * @throws mpack_error_type If the value is not a string or contains
+ *     invalid UTF-8 or a null byte.
+ */
+char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize);
+#endif
+
+/**
+ * Reads a string, ensuring it exactly matches the given null-terminated
+ * string.
+ *
+ * Remember that maps are unordered in JSON. Don't use this for map keys
+ * unless the map has only a single key!
+ */
+MPACK_INLINE void mpack_expect_cstr_match(mpack_reader_t* reader, const char* cstr) {
+    mpack_assert(cstr != NULL, "cstr pointer is NULL");
+    mpack_expect_str_match(reader, cstr, mpack_strlen(cstr));
+}
+
+/**
+ * @}
+ */
+
+/**
+ * @name Binary Data
+ * @{
+ */
+
+/**
+ * Reads the start of a binary blob, returning its size in bytes.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
+ * once all bytes have been read.
+ *
+ * mpack_error_type is raised if the value is not a binary blob.
+ */
+uint32_t mpack_expect_bin(mpack_reader_t* reader);
+
+/**
+ * Reads the start of a binary blob, raising an error if its length is not
+ * at most the given number of bytes.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
+ * once all bytes have been read.
+ *
+ * mpack_error_type is raised if the value is not a binary blob or if its
+ * length does not match.
+ */
+MPACK_INLINE uint32_t mpack_expect_bin_max(mpack_reader_t* reader, uint32_t maxsize) {
+    uint32_t length = mpack_expect_bin(reader);
+    if (length > maxsize) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return 0;
+    }
+    return length;
+}
+
+/**
+ * Reads the start of a binary blob, raising an error if its length is not
+ * exactly the given number of bytes.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
+ * once all bytes have been read.
+ *
+ * @throws mpack_error_type if the value is not a binary blob or if its size
+ * does not match.
+ */
+MPACK_INLINE void mpack_expect_bin_size(mpack_reader_t* reader, uint32_t count) {
+    if (mpack_expect_bin(reader) != count)
+        mpack_reader_flag_error(reader, mpack_error_type);
+}
+
+/**
+ * Reads a binary blob into the given buffer, returning its size in bytes.
+ *
+ * For compatibility, this will accept if the underlying type is string or
+ * binary (since in MessagePack 1.0, strings and binary data were combined
+ * under the "raw" type which became string in 1.1.)
+ */
+size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t size);
+
+/**
+ * Reads a binary blob with the exact given size into the given buffer.
+ *
+ * For compatibility, this will accept if the underlying type is string or
+ * binary (since in MessagePack 1.0, strings and binary data were combined
+ * under the "raw" type which became string in 1.1.)
+ *
+ * @throws mpack_error_type if the value is not a binary blob or if its size
+ * does not match.
+ */
+void mpack_expect_bin_size_buf(mpack_reader_t* reader, char* buf, uint32_t size);
+
+/**
+ * Reads a binary blob with the given total maximum size, allocating storage for it.
+ */
+char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Extension Functions
+ * @{
+ */
+
+#if MPACK_EXTENSIONS
+/**
+ * Reads the start of an extension blob, returning its size in bytes and
+ * placing the type into @p type.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
+ * once all bytes have been read.
+ *
+ * @p type will be a user-defined type in the range [0,127] or a reserved type
+ * in the range [-128,-2].
+ *
+ * mpack_error_type is raised if the value is not an extension blob. The @p
+ * type value is zero if an error occurs.
+ *
+ * @note This cannot be used to match a timestamp. @ref mpack_error_type will
+ * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
+ * mpack_expect_timestamp_truncate() instead.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @warning Be careful when using reserved types. They may no longer be ext
+ * types in the future, and previously valid data containing reserved types may
+ * become invalid in the future.
+ */
+uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type);
+
+/**
+ * Reads the start of an extension blob, raising an error if its length is not
+ * at most the given number of bytes and placing the type into @p type.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
+ * once all bytes have been read.
+ *
+ * mpack_error_type is raised if the value is not an extension blob or if its
+ * length does not match. The @p type value is zero if an error is raised.
+ *
+ * @p type will be a user-defined type in the range [0,127] or a reserved type
+ * in the range [-128,-2].
+ *
+ * @note This cannot be used to match a timestamp. @ref mpack_error_type will
+ * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
+ * mpack_expect_timestamp_truncate() instead.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @warning Be careful when using reserved types. They may no longer be ext
+ * types in the future, and previously valid data containing reserved types may
+ * become invalid in the future.
+ *
+ * @see mpack_expect_ext()
+ */
+MPACK_INLINE uint32_t mpack_expect_ext_max(mpack_reader_t* reader, int8_t* type, uint32_t maxsize) {
+    uint32_t length = mpack_expect_ext(reader, type);
+    if (length > maxsize) {
+        mpack_reader_flag_error(reader, mpack_error_type);
+        return 0;
+    }
+    return length;
+}
+
+/**
+ * Reads the start of an extension blob, raising an error if its length is not
+ * exactly the given number of bytes and placing the type into @p type.
+ *
+ * The bytes follow and must be read separately with mpack_read_bytes()
+ * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
+ * once all bytes have been read.
+ *
+ * mpack_error_type is raised if the value is not an extension blob or if its
+ * length does not match. The @p type value is zero if an error is raised.
+ *
+ * @p type will be a user-defined type in the range [0,127] or a reserved type
+ * in the range [-128,-2].
+ *
+ * @note This cannot be used to match a timestamp. @ref mpack_error_type will
+ * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
+ * mpack_expect_timestamp_truncate() instead.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @warning Be careful when using reserved types. They may no longer be ext
+ * types in the future, and previously valid data containing reserved types may
+ * become invalid in the future.
+ *
+ * @see mpack_expect_ext()
+ */
+MPACK_INLINE void mpack_expect_ext_size(mpack_reader_t* reader, int8_t* type, uint32_t count) {
+    if (mpack_expect_ext(reader, type) != count) {
+        *type = 0;
+        mpack_reader_flag_error(reader, mpack_error_type);
+    }
+}
+
+/**
+ * Reads an extension blob into the given buffer, returning its size in bytes
+ * and placing the type into @p type.
+ *
+ * mpack_error_type is raised if the value is not an extension blob or if its
+ * length does not match. The @p type value is zero if an error is raised.
+ *
+ * @p type will be a user-defined type in the range [0,127] or a reserved type
+ * in the range [-128,-2].
+ *
+ * @note This cannot be used to match a timestamp. @ref mpack_error_type will
+ * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
+ * mpack_expect_timestamp_truncate() instead.
+ *
+ * @warning Be careful when using reserved types. They may no longer be ext
+ * types in the future, and previously valid data containing reserved types may
+ * become invalid in the future.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @see mpack_expect_ext()
+ */
+size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t size);
+#endif
+
+#if MPACK_EXTENSIONS && defined(MPACK_MALLOC)
+/**
+ * Reads an extension blob with the given total maximum size, allocating
+ * storage for it, and placing the type into @p type.
+ *
+ * mpack_error_type is raised if the value is not an extension blob or if its
+ * length does not match. The @p type value is zero if an error is raised.
+ *
+ * @p type will be a user-defined type in the range [0,127] or a reserved type
+ * in the range [-128,-2].
+ *
+ * @note This cannot be used to match a timestamp. @ref mpack_error_type will
+ * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
+ * mpack_expect_timestamp_truncate() instead.
+ *
+ * @warning Be careful when using reserved types. They may no longer be ext
+ * types in the future, and previously valid data containing reserved types may
+ * become invalid in the future.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS and @ref MPACK_MALLOC.
+ *
+ * @see mpack_expect_ext()
+ */
+char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Special Functions
+ * @{
+ */
+
+/**
+ * Reads a MessagePack object header (an MPack tag), expecting it to exactly
+ * match the given tag.
+ *
+ * If the type is compound (i.e. is a map, array, string, binary or
+ * extension type), additional reads are required to get the contained
+ * data, and the corresponding done function must be called when done.
+ *
+ * @throws mpack_error_type if the tag does not match
+ *
+ * @see mpack_read_bytes()
+ * @see mpack_done_array()
+ * @see mpack_done_map()
+ * @see mpack_done_str()
+ * @see mpack_done_bin()
+ * @see mpack_done_ext()
+ */
+void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t tag);
+
+/**
+ * Expects a string matching one of the strings in the given array,
+ * returning its array index.
+ *
+ * If the value does not match any of the given strings,
+ * @ref mpack_error_type is flagged. Use mpack_expect_enum_optional()
+ * if you want to allow other values than the given strings.
+ *
+ * If any error occurs or the reader is in an error state, @a count
+ * is returned.
+ *
+ * This can be used to quickly parse a string into an enum when the
+ * enum values range from 0 to @a count-1. If the last value in the
+ * enum is a special "count" value, it can be passed as the count,
+ * and the return value can be cast directly to the enum type.
+ *
+ * @code{.c}
+ * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
+ * const char* fruits[] = {"apple", "banana", "orange"};
+ *
+ * fruit_t fruit = (fruit_t)mpack_expect_enum(reader, fruits, COUNT);
+ * @endcode
+ *
+ * See @ref docs/expect.md for more examples.
+ *
+ * The maximum string length is the size of the buffer (strings are read in-place.)
+ *
+ * @param reader The reader
+ * @param strings An array of expected strings of length count
+ * @param count The number of strings
+ * @return The index of the matched string, or @a count in case of error
+ */
+size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count);
+
+/**
+ * Expects a string matching one of the strings in the given array
+ * returning its array index, or @a count if no strings match.
+ *
+ * If the value is not a string, or it does not match any of the
+ * given strings, @a count is returned and no error is flagged.
+ *
+ * If any error occurs or the reader is in an error state, @a count
+ * is returned.
+ *
+ * This can be used to quickly parse a string into an enum when the
+ * enum values range from 0 to @a count-1. If the last value in the
+ * enum is a special "count" value, it can be passed as the count,
+ * and the return value can be cast directly to the enum type.
+ *
+ * @code{.c}
+ * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
+ * const char* fruits[] = {"apple", "banana", "orange"};
+ *
+ * fruit_t fruit = (fruit_t)mpack_expect_enum_optional(reader, fruits, COUNT);
+ * @endcode
+ *
+ * See @ref docs/expect.md for more examples.
+ *
+ * The maximum string length is the size of the buffer (strings are read in-place.)
+ *
+ * @param reader The reader
+ * @param strings An array of expected strings of length count
+ * @param count The number of strings
+ *
+ * @return The index of the matched string, or @a count if it does not
+ * match or an error occurs
+ */
+size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count);
+
+/**
+ * Expects an unsigned integer map key between 0 and count-1, marking it
+ * as found in the given bool array and returning it.
+ *
+ * This is a helper for switching among int keys in a map. It is
+ * typically used with an enum to define the key values. It should
+ * be called in the expression of a switch() statement. See @ref
+ * docs/expect.md for an example.
+ *
+ * The found array must be cleared before expecting the first key. If the
+ * flag for a given key is already set when found (i.e. the map contains a
+ * duplicate key), mpack_error_invalid is flagged.
+ *
+ * If the key is not a non-negative integer, or if the key is @a count or
+ * larger, @a count is returned and no error is flagged. If you want an error
+ * on unrecognized keys, flag an error in the default case in your switch;
+ * otherwise you must call mpack_discard() to discard its content.
+ *
+ * @param reader The reader
+ * @param found An array of bool flags of length count
+ * @param count The number of values in the found array, and one more than the
+ *              maximum allowed key
+ *
+ * @see @ref docs/expect.md
+ */
+size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count);
+
+/**
+ * Expects a string map key matching one of the strings in the given key list,
+ * marking it as found in the given bool array and returning its index.
+ *
+ * This is a helper for switching among string keys in a map. It is
+ * typically used with an enum with names matching the strings in the
+ * array to define the key indices. It should be called in the expression
+ * of a switch() statement. See @ref docs/expect.md for an example.
+ *
+ * The found array must be cleared before expecting the first key. If the
+ * flag for a given key is already set when found (i.e. the map contains a
+ * duplicate key), mpack_error_invalid is flagged.
+ *
+ * If the key is unrecognized, count is returned and no error is flagged. If
+ * you want an error on unrecognized keys, flag an error in the default case
+ * in your switch; otherwise you must call mpack_discard() to discard its content.
+ *
+ * The maximum key length is the size of the buffer (keys are read in-place.)
+ *
+ * @param reader The reader
+ * @param keys An array of expected string keys of length count
+ * @param found An array of bool flags of length count
+ * @param count The number of values in the keys and found arrays
+ *
+ * @see @ref docs/expect.md
+ */
+size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[],
+        bool found[], size_t count);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#endif
+
+MPACK_EXTERN_C_END
+MPACK_HEADER_END
+
+#endif
+
+
+
+/* mpack/mpack-node.h.h */
+
+/**
+ * @file
+ *
+ * Declares the MPack dynamic Node API.
+ */
+
+#ifndef MPACK_NODE_H
+#define MPACK_NODE_H 1
+
+/* #include "mpack-reader.h" */
+
+MPACK_HEADER_START
+MPACK_EXTERN_C_START
+
+#if MPACK_NODE
+
+/**
+ * @defgroup node Node API
+ *
+ * The MPack Node API allows you to parse a chunk of MessagePack into a
+ * dynamically typed data structure, providing random access to the parsed
+ * data.
+ *
+ * See @ref docs/node.md for examples.
+ *
+ * @{
+ */
+
+/**
+ * A handle to node data in a parsed MPack tree.
+ *
+ * Nodes represent either primitive values or compound types. If a
+ * node is a compound type, it contains a pointer to its child nodes,
+ * or a pointer to its underlying data.
+ *
+ * Nodes are immutable.
+ *
+ * @note @ref mpack_node_t is an opaque reference to the node data, not the
+ * node data itself. (It contains pointers to both the node data and the tree.)
+ * It is passed by value in the Node API.
+ */
+typedef struct mpack_node_t mpack_node_t;
+
+/**
+ * The storage for nodes in an MPack tree.
+ *
+ * You only need to use this if you intend to provide your own storage
+ * for nodes instead of letting the tree allocate it.
+ *
+ * @ref mpack_node_data_t is 16 bytes on most common architectures (32-bit
+ * and 64-bit.)
+ */
+typedef struct mpack_node_data_t mpack_node_data_t;
+
+/**
+ * An MPack tree parser to parse a blob or stream of MessagePack.
+ *
+ * When a message is parsed, the tree contains a single root node which
+ * contains all parsed data. The tree and its nodes are immutable.
+ */
+typedef struct mpack_tree_t mpack_tree_t;
+
+/**
+ * An error handler function to be called when an error is flagged on
+ * the tree.
+ *
+ * The error handler will only be called once on the first error flagged;
+ * any subsequent node reads and errors are ignored, and the tree is
+ * permanently in that error state.
+ *
+ * MPack is safe against non-local jumps out of error handler callbacks.
+ * This means you are allowed to longjmp or throw an exception (in C++,
+ * Objective-C, or with SEH) out of this callback.
+ *
+ * Bear in mind when using longjmp that local non-volatile variables that
+ * have changed are undefined when setjmp() returns, so you can't put the
+ * tree on the stack in the same activation frame as the setjmp without
+ * declaring it volatile.
+ *
+ * You must still eventually destroy the tree. It is not destroyed
+ * automatically when an error is flagged. It is safe to destroy the
+ * tree within this error callback, but you will either need to perform
+ * a non-local jump, or store something in your context to identify
+ * that the tree is destroyed since any future accesses to it cause
+ * undefined behavior.
+ */
+typedef void (*mpack_tree_error_t)(mpack_tree_t* tree, mpack_error_t error);
+
+/**
+ * The MPack tree's read function. It should fill the buffer with as many bytes
+ * as are immediately available up to the given @c count, returning the number
+ * of bytes written to the buffer.
+ *
+ * In case of error, it should flag an appropriate error on the reader
+ * (usually @ref mpack_error_io.)
+ *
+ * The blocking or non-blocking behaviour of the read should match whether you
+ * are using mpack_tree_parse() or mpack_tree_try_parse().
+ *
+ * If you are using mpack_tree_parse(), the read should block until at least
+ * one byte is read. If you return 0, mpack_tree_parse() will raise @ref
+ * mpack_error_io.
+ *
+ * If you are using mpack_tree_try_parse(), the read function can always
+ * return 0, and must never block waiting for data (otherwise
+ * mpack_tree_try_parse() would be equivalent to mpack_tree_parse().)
+ * When you return 0, mpack_tree_try_parse() will return false without flagging
+ * an error.
+ */
+typedef size_t (*mpack_tree_read_t)(mpack_tree_t* tree, char* buffer, size_t count);
+
+/**
+ * A teardown function to be called when the tree is destroyed.
+ */
+typedef void (*mpack_tree_teardown_t)(mpack_tree_t* tree);
+
+
+
+/* Hide internals from documentation */
+/** @cond */
+
+struct mpack_node_t {
+    mpack_node_data_t* data;
+    mpack_tree_t* tree;
+};
+
+struct mpack_node_data_t {
+    mpack_type_t type;
+
+    /*
+     * The element count if the type is an array;
+     * the number of key/value pairs if the type is map;
+     * or the number of bytes if the type is str, bin or ext.
+     */
+    uint32_t len;
+
+    union
+    {
+        bool     b; /* The value if the type is bool. */
+        float    f; /* The value if the type is float. */
+        double   d; /* The value if the type is double. */
+        int64_t  i; /* The value if the type is signed int. */
+        uint64_t u; /* The value if the type is unsigned int. */
+        size_t offset; /* The byte offset for str, bin and ext */
+        mpack_node_data_t* children; /* The children for map or array */
+    } value;
+};
+
+typedef struct mpack_tree_page_t {
+    struct mpack_tree_page_t* next;
+    mpack_node_data_t nodes[1]; // variable size
+} mpack_tree_page_t;
+
+typedef enum mpack_tree_parse_state_t {
+    mpack_tree_parse_state_not_started,
+    mpack_tree_parse_state_in_progress,
+    mpack_tree_parse_state_parsed,
+} mpack_tree_parse_state_t;
+
+typedef struct mpack_level_t {
+    mpack_node_data_t* child;
+    size_t left; // children left in level
+} mpack_level_t;
+
+typedef struct mpack_tree_parser_t {
+    mpack_tree_parse_state_t state;
+
+    // We keep track of the number of "possible nodes" left in the data rather
+    // than the number of bytes.
+    //
+    // When a map or array is parsed, we ensure at least one byte for each child
+    // exists and subtract them right away. This ensures that if ever a map or
+    // array declares more elements than could possibly be contained in the data,
+    // we will error out immediately rather than allocating storage for them.
+    //
+    // For example malicious data that repeats 0xDE 0xFF 0xFF (start of a map
+    // with 65536 key-value pairs) would otherwise cause us to run out of
+    // memory. With this, the parser can allocate at most as many nodes as
+    // there are bytes in the data (plus the paging overhead, 12%.) An error
+    // will be flagged immediately if and when there isn't enough data left to
+    // fully read all children of all open compound types on the parsing stack.
+    //
+    // Once an entire message has been parsed (and there are no nodes left to
+    // parse whose bytes have been subtracted), this matches the number of left
+    // over bytes in the data.
+    size_t possible_nodes_left;
+
+    mpack_node_data_t* nodes; // next node in current page/pool
+    size_t nodes_left; // nodes left in current page/pool
+
+    size_t current_node_reserved;
+    size_t level;
+
+    #ifdef MPACK_MALLOC
+    // It's much faster to allocate the initial parsing stack inline within the
+    // parser. We replace it with a heap allocation if we need to grow it.
+    mpack_level_t* stack;
+    size_t stack_capacity;
+    bool stack_owned;
+    mpack_level_t stack_local[MPACK_NODE_INITIAL_DEPTH];
+    #else
+    // Without malloc(), we have to reserve a parsing stack the maximum allowed
+    // parsing depth.
+    mpack_level_t stack[MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC];
+    #endif
+} mpack_tree_parser_t;
+
+struct mpack_tree_t {
+    mpack_tree_error_t error_fn;    /* Function to call on error */
+    mpack_tree_read_t read_fn;      /* Function to call to read more data */
+    mpack_tree_teardown_t teardown; /* Function to teardown the context on destroy */
+    void* context;                  /* Context for tree callbacks */
+
+    mpack_node_data_t nil_node;     /* a nil node to be returned in case of error */
+    mpack_node_data_t missing_node; /* a missing node to be returned in optional lookups */
+    mpack_error_t error;
+
+    #ifdef MPACK_MALLOC
+    char* buffer;
+    size_t buffer_capacity;
+    #endif
+
+    const char* data;
+    size_t data_length; // length of data (and content of buffer, if used)
+
+    size_t size; // size in bytes of tree (usually matches data_length, but not if tree has trailing data)
+    size_t node_count; // total number of nodes in tree (across all pages)
+
+    size_t max_size;  // maximum message size
+    size_t max_nodes; // maximum nodes in a message
+
+    mpack_tree_parser_t parser;
+    mpack_node_data_t* root;
+
+    mpack_node_data_t* pool; // pool, or NULL if no pool provided
+    size_t pool_count;
+
+    #ifdef MPACK_MALLOC
+    mpack_tree_page_t* next;
+    #endif
+};
+
+// internal functions
+
+MPACK_INLINE mpack_node_t mpack_node(mpack_tree_t* tree, mpack_node_data_t* data) {
+    mpack_node_t node;
+    node.data = data;
+    node.tree = tree;
+    return node;
+}
+
+MPACK_INLINE mpack_node_data_t* mpack_node_child(mpack_node_t node, size_t child) {
+    return node.data->value.children + child;
+}
+
+MPACK_INLINE mpack_node_t mpack_tree_nil_node(mpack_tree_t* tree) {
+    return mpack_node(tree, &tree->nil_node);
+}
+
+MPACK_INLINE mpack_node_t mpack_tree_missing_node(mpack_tree_t* tree) {
+    return mpack_node(tree, &tree->missing_node);
+}
+
+/** @endcond */
+
+
+
+/**
+ * @name Tree Initialization
+ * @{
+ */
+
+#ifdef MPACK_MALLOC
+/**
+ * Initializes a tree parser with the given data.
+ *
+ * Configure the tree if desired, then call mpack_tree_parse() to parse it. The
+ * tree will allocate pages of nodes as needed and will free them when
+ * destroyed.
+ *
+ * The tree must be destroyed with mpack_tree_destroy().
+ *
+ * Any string or blob data types reference the original data, so the given data
+ * pointer must remain valid until after the tree is destroyed.
+ */
+void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length);
+
+/**
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_tree_init_data().
+ */
+MPACK_INLINE void mpack_tree_init(mpack_tree_t* tree, const char* data, size_t length) {
+    mpack_tree_init_data(tree, data, length);
+}
+
+/**
+ * Initializes a tree parser from an unbounded stream, or a stream of
+ * unknown length.
+ *
+ * The parser can be used to read a single message from a stream of unknown
+ * length, or multiple messages from an unbounded stream, allowing it to
+ * be used for RPC communication. Call @ref mpack_tree_parse() to parse
+ * a message from a blocking stream, or @ref mpack_tree_try_parse() for a
+ * non-blocking stream.
+ *
+ * The stream will use a growable internal buffer to store the most recent
+ * message, as well as allocated pages of nodes for the parse tree.
+ *
+ * Maximum allowances for message size and node count must be specified in this
+ * function (since the stream is unbounded.) They can be changed later with
+ * @ref mpack_tree_set_limits().
+ *
+ * @param tree The tree parser
+ * @param read_fn The read function
+ * @param context The context for the read function
+ * @param max_message_size The maximum size of a message in bytes
+ * @param max_message_nodes The maximum number of nodes per message. See
+ *        @ref mpack_node_data_t for the size of nodes.
+ *
+ * @see mpack_tree_read_t
+ * @see mpack_reader_context()
+ */
+void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context,
+        size_t max_message_size, size_t max_message_nodes);
+#endif
+
+/**
+ * Initializes a tree parser with the given data, using the given node data
+ * pool to store the results.
+ *
+ * Configure the tree if desired, then call mpack_tree_parse() to parse it.
+ *
+ * If the data does not fit in the pool, @ref mpack_error_too_big will be flagged
+ * on the tree.
+ *
+ * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails.
+ */
+void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length,
+        mpack_node_data_t* node_pool, size_t node_pool_count);
+
+/**
+ * Initializes an MPack tree directly into an error state. Use this if you
+ * are writing a wrapper to another <tt>mpack_tree_init*()</tt> function which
+ * can fail its setup.
+ */
+void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error);
+
+#if MPACK_STDIO
+/**
+ * Initializes a tree to parse the given file. The tree must be destroyed with
+ * mpack_tree_destroy(), even if parsing fails.
+ *
+ * The file is opened, loaded fully into memory, and closed before this call
+ * returns.
+ *
+ * @param tree The tree to initialize
+ * @param filename The filename passed to fopen() to read the file
+ * @param max_bytes The maximum size of file to load, or 0 for unlimited size.
+ */
+void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes);
+
+/**
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_tree_init_filename().
+ */
+MPACK_INLINE void mpack_tree_init_file(mpack_tree_t* tree, const char* filename, size_t max_bytes) {
+    mpack_tree_init_filename(tree, filename, max_bytes);
+}
+
+/**
+ * Initializes a tree to parse the given libc FILE. This can be used to
+ * read from stdin, or from a file opened separately.
+ *
+ * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails.
+ *
+ * The FILE is fully loaded fully into memory (and closed if requested) before
+ * this call returns.
+ *
+ * @param tree The tree to initialize.
+ * @param stdfile The FILE.
+ * @param max_bytes The maximum size of file to load, or 0 for unlimited size.
+ * @param close_when_done If true, fclose() will be called on the FILE when it
+ *         is no longer needed. If false, the file will not be closed when
+ *         reading is done.
+ *
+ * @warning The tree will read all data in the FILE before parsing it. If this
+ *          is used on stdin, the parser will block until it is closed, even if
+ *          a complete message has been written to it!
+ */
+void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Tree Functions
+ * @{
+ */
+
+/**
+ * Sets the maximum byte size and maximum number of nodes allowed per message.
+ *
+ * The default is SIZE_MAX (no limit) unless @ref mpack_tree_init_stream() is
+ * called (where maximums are required.)
+ *
+ * If a pool of nodes is used, the node limit is the lesser of this limit and
+ * the pool size.
+ *
+ * @param tree The tree parser
+ * @param max_message_size The maximum size of a message in bytes
+ * @param max_message_nodes The maximum number of nodes per message. See
+ *        @ref mpack_node_data_t for the size of nodes.
+ */
+void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size,
+        size_t max_message_nodes);
+
+/**
+ * Parses a MessagePack message into a tree of immutable nodes.
+ *
+ * If successful, the root node will be available under @ref mpack_tree_root().
+ * If not, an appropriate error will be flagged.
+ *
+ * This can be called repeatedly to parse a series of messages from a data
+ * source. When this is called, all previous nodes from this tree and their
+ * contents (including the root node) are invalidated.
+ *
+ * If this is called with a stream (see @ref mpack_tree_init_stream()), the
+ * stream must block until data is available. (Otherwise, if this is called on
+ * a non-blocking stream, parsing will fail with @ref mpack_error_io when the
+ * fill function returns 0.)
+ *
+ * There is no way to recover a tree in an error state. It must be destroyed.
+ */
+void mpack_tree_parse(mpack_tree_t* tree);
+
+/**
+ * Attempts to parse a MessagePack message from a non-blocking stream into a
+ * tree of immutable nodes.
+ *
+ * A non-blocking read function must have been passed to the tree in
+ * mpack_tree_init_stream().
+ *
+ * If this returns true, a message is available under
+ * @ref mpack_tree_root(). The tree nodes and data will be valid until
+ * the next time a parse is started.
+ *
+ * If this returns false, no message is available, because either not enough
+ * data is available yet or an error has occurred. You must check the tree for
+ * errors whenever this returns false. If there is no error, you should try
+ * again later when more data is available. (You will want to select()/poll()
+ * on the underlying socket or use some other asynchronous mechanism to
+ * determine when it has data.)
+ *
+ * There is no way to recover a tree in an error state. It must be destroyed.
+ *
+ * @see mpack_tree_init_stream()
+ */
+bool mpack_tree_try_parse(mpack_tree_t* tree);
+
+/**
+ * Returns the root node of the tree, if the tree is not in an error state.
+ * Returns a nil node otherwise.
+ *
+ * @warning You must call mpack_tree_parse() before calling this. If
+ * @ref mpack_tree_parse() was never called, the tree will assert.
+ */
+mpack_node_t mpack_tree_root(mpack_tree_t* tree);
+
+/**
+ * Returns the error state of the tree.
+ */
+MPACK_INLINE mpack_error_t mpack_tree_error(mpack_tree_t* tree) {
+    return tree->error;
+}
+
+/**
+ * Returns the size in bytes of the current parsed message.
+ *
+ * If there is something in the buffer after the MessagePack object, this can
+ * be used to find it.
+ *
+ * This is zero if an error occurred during tree parsing (since the
+ * portion of the data that the first complete object occupies cannot
+ * be determined if the data is invalid or corrupted.)
+ */
+MPACK_INLINE size_t mpack_tree_size(mpack_tree_t* tree) {
+    return tree->size;
+}
+
+/**
+ * Destroys the tree.
+ */
+mpack_error_t mpack_tree_destroy(mpack_tree_t* tree);
+
+/**
+ * Sets the custom pointer to pass to the tree callbacks, such as teardown.
+ *
+ * @param tree The MPack tree.
+ * @param context User data to pass to the tree callbacks.
+ *
+ * @see mpack_reader_context()
+ */
+MPACK_INLINE void mpack_tree_set_context(mpack_tree_t* tree, void* context) {
+    tree->context = context;
+}
+
+/**
+ * Returns the custom context for tree callbacks.
+ *
+ * @see mpack_tree_set_context
+ * @see mpack_tree_init_stream
+ */
+MPACK_INLINE void* mpack_tree_context(mpack_tree_t* tree) {
+    return tree->context;
+}
+
+/**
+ * Sets the error function to call when an error is flagged on the tree.
+ *
+ * This should normally be used with mpack_tree_set_context() to register
+ * a custom pointer to pass to the error function.
+ *
+ * See the definition of mpack_tree_error_t for more information about
+ * what you can do from an error callback.
+ *
+ * @see mpack_tree_error_t
+ * @param tree The MPack tree.
+ * @param error_fn The function to call when an error is flagged on the tree.
+ */
+MPACK_INLINE void mpack_tree_set_error_handler(mpack_tree_t* tree, mpack_tree_error_t error_fn) {
+    tree->error_fn = error_fn;
+}
+
+/**
+ * Sets the teardown function to call when the tree is destroyed.
+ *
+ * This should normally be used with mpack_tree_set_context() to register
+ * a custom pointer to pass to the teardown function.
+ *
+ * @param tree The MPack tree.
+ * @param teardown The function to call when the tree is destroyed.
+ */
+MPACK_INLINE void mpack_tree_set_teardown(mpack_tree_t* tree, mpack_tree_teardown_t teardown) {
+    tree->teardown = teardown;
+}
+
+/**
+ * Places the tree in the given error state, calling the error callback if one
+ * is set.
+ *
+ * This allows you to externally flag errors, for example if you are validating
+ * data as you read it.
+ *
+ * If the tree is already in an error state, this call is ignored and no
+ * error callback is called.
+ */
+void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Node Core Functions
+ * @{
+ */
+
+/**
+ * Places the node's tree in the given error state, calling the error callback
+ * if one is set.
+ *
+ * This allows you to externally flag errors, for example if you are validating
+ * data as you read it.
+ *
+ * If the tree is already in an error state, this call is ignored and no
+ * error callback is called.
+ */
+void mpack_node_flag_error(mpack_node_t node, mpack_error_t error);
+
+/**
+ * Returns the error state of the node's tree.
+ */
+MPACK_INLINE mpack_error_t mpack_node_error(mpack_node_t node) {
+    return mpack_tree_error(node.tree);
+}
+
+/**
+ * Returns a tag describing the given node, or a nil tag if the
+ * tree is in an error state.
+ */
+mpack_tag_t mpack_node_tag(mpack_node_t node);
+
+/** @cond */
+
+#if MPACK_DEBUG && MPACK_STDIO
+/*
+ * Converts a node to a pseudo-JSON string for debugging purposes, placing the
+ * result in the given buffer with a null-terminator.
+ *
+ * If the buffer does not have enough space, the result will be truncated (but
+ * it is guaranteed to be null-terminated.)
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size);
+
+/*
+ * Converts a node to pseudo-JSON for debugging purposes, calling the given
+ * callback as many times as is necessary to output the character data.
+ *
+ * No null-terminator or trailing newline will be written.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context);
+
+/*
+ * Converts a node to pseudo-JSON for debugging purposes
+ * and pretty-prints it to the given file.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+void mpack_node_print_to_file(mpack_node_t node, FILE* file);
+
+/*
+ * Converts a node to pseudo-JSON for debugging purposes
+ * and pretty-prints it to stdout.
+ *
+ * This is only available in debug mode, and only if stdio is available (since
+ * it uses snprintf().) It's strictly for debugging purposes.
+ */
+MPACK_INLINE void mpack_node_print_to_stdout(mpack_node_t node) {
+    mpack_node_print_to_file(node, stdout);
+}
+
+/*
+ * Deprecated.
+ *
+ * \deprecated Renamed to mpack_node_print_to_stdout().
+ */
+MPACK_INLINE void mpack_node_print(mpack_node_t node) {
+    mpack_node_print_to_stdout(node);
+}
+#endif
+
+/** @endcond */
+
+/**
+ * @}
+ */
+
+/**
+ * @name Node Primitive Value Functions
+ * @{
+ */
+
+/**
+ * Returns the type of the node.
+ */
+mpack_type_t mpack_node_type(mpack_node_t node);
+
+/**
+ * Returns true if the given node is a nil node; false otherwise.
+ *
+ * To ensure that a node is nil and flag an error otherwise, use
+ * mpack_node_nil().
+ */
+bool mpack_node_is_nil(mpack_node_t node);
+
+/**
+ * Returns true if the given node handle indicates a missing node; false otherwise.
+ *
+ * To ensure that a node is missing and flag an error otherwise, use
+ * mpack_node_missing().
+ */
+bool mpack_node_is_missing(mpack_node_t node);
+
+/**
+ * Checks that the given node is of nil type, raising @ref mpack_error_type
+ * otherwise.
+ *
+ * Use mpack_node_is_nil() to return whether the node is nil.
+ */
+void mpack_node_nil(mpack_node_t node);
+
+/**
+ * Checks that the given node indicates a missing node, raising @ref
+ * mpack_error_type otherwise.
+ *
+ * Use mpack_node_is_missing() to return whether the node is missing.
+ */
+void mpack_node_missing(mpack_node_t node);
+
+/**
+ * Returns the bool value of the node. If this node is not of the correct
+ * type, false is returned and mpack_error_type is raised.
+ */
+bool mpack_node_bool(mpack_node_t node);
+
+/**
+ * Checks if the given node is of bool type with value true, raising
+ * mpack_error_type otherwise.
+ */
+void mpack_node_true(mpack_node_t node);
+
+/**
+ * Checks if the given node is of bool type with value false, raising
+ * mpack_error_type otherwise.
+ */
+void mpack_node_false(mpack_node_t node);
+
+/**
+ * Returns the 8-bit unsigned value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+uint8_t mpack_node_u8(mpack_node_t node);
+
+/**
+ * Returns the 8-bit signed value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+int8_t mpack_node_i8(mpack_node_t node);
+
+/**
+ * Returns the 16-bit unsigned value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+uint16_t mpack_node_u16(mpack_node_t node);
+
+/**
+ * Returns the 16-bit signed value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+int16_t mpack_node_i16(mpack_node_t node);
+
+/**
+ * Returns the 32-bit unsigned value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+uint32_t mpack_node_u32(mpack_node_t node);
+
+/**
+ * Returns the 32-bit signed value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+int32_t mpack_node_i32(mpack_node_t node);
+
+/**
+ * Returns the 64-bit unsigned value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised, and zero is returned.
+ */
+uint64_t mpack_node_u64(mpack_node_t node);
+
+/**
+ * Returns the 64-bit signed value of the node. If this node is not
+ * of a compatible type, @ref mpack_error_type is raised and zero is returned.
+ */
+int64_t mpack_node_i64(mpack_node_t node);
+
+/**
+ * Returns the unsigned int value of the node.
+ *
+ * Returns zero if an error occurs.
+ *
+ * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an unsigned int
+ */
+unsigned int mpack_node_uint(mpack_node_t node);
+
+/**
+ * Returns the int value of the node.
+ *
+ * Returns zero if an error occurs.
+ *
+ * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an int
+ */
+int mpack_node_int(mpack_node_t node);
+
+/**
+ * Returns the float value of the node. The underlying value can be an
+ * integer, float or double; the value is converted to a float.
+ *
+ * @note Reading a double or a large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+float mpack_node_float(mpack_node_t node);
+
+/**
+ * Returns the double value of the node. The underlying value can be an
+ * integer, float or double; the value is converted to a double.
+ *
+ * @note Reading a very large integer with this function can incur a
+ * loss of precision.
+ *
+ * @throws mpack_error_type if the underlying value is not a float, double or integer.
+ */
+double mpack_node_double(mpack_node_t node);
+
+/**
+ * Returns the float value of the node. The underlying value must be a float,
+ * not a double or an integer. This ensures no loss of precision can occur.
+ *
+ * @throws mpack_error_type if the underlying value is not a float.
+ */
+float mpack_node_float_strict(mpack_node_t node);
+
+/**
+ * Returns the double value of the node. The underlying value must be a float
+ * or double, not an integer. This ensures no loss of precision can occur.
+ *
+ * @throws mpack_error_type if the underlying value is not a float or double.
+ */
+double mpack_node_double_strict(mpack_node_t node);
+
+#if MPACK_EXTENSIONS
+/**
+ * Returns a timestamp.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @throws mpack_error_type if the underlying value is not a timestamp.
+ */
+mpack_timestamp_t mpack_node_timestamp(mpack_node_t node);
+
+/**
+ * Returns a timestamp's (signed) seconds since 1970-01-01T00:00:00Z.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @throws mpack_error_type if the underlying value is not a timestamp.
+ */
+int64_t mpack_node_timestamp_seconds(mpack_node_t node);
+
+/**
+ * Returns a timestamp's additional nanoseconds.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ *
+ * @return A nanosecond count between 0 and 999,999,999 inclusive.
+ * @throws mpack_error_type if the underlying value is not a timestamp.
+ */
+uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node);
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @name Node String and Data Functions
+ * @{
+ */
+
+/**
+ * Checks that the given node contains a valid UTF-8 string.
+ *
+ * If the string is invalid, this flags an error, which would cause subsequent calls
+ * to mpack_node_str() to return NULL and mpack_node_strlen() to return zero. So you
+ * can check the node for error immediately after calling this, or you can call those
+ * functions to use the data anyway and check for errors later.
+ *
+ * @throws mpack_error_type If this node is not a string or does not contain valid UTF-8.
+ *
+ * @param node The string node to test
+ *
+ * @see mpack_node_str()
+ * @see mpack_node_strlen()
+ */
+void mpack_node_check_utf8(mpack_node_t node);
+
+/**
+ * Checks that the given node contains a valid UTF-8 string with no NUL bytes.
+ *
+ * This does not check that the string has a null-terminator! It only checks whether
+ * the string could safely be represented as a C-string by appending a null-terminator.
+ * (If the string does already contain a null-terminator, this will flag an error.)
+ *
+ * This is performed automatically by other UTF-8 cstr helper functions. Only
+ * call this if you will do something else with the data directly, but you still
+ * want to ensure it will be valid as a UTF-8 C-string.
+ *
+ * @throws mpack_error_type If this node is not a string, does not contain valid UTF-8,
+ *     or contains a NUL byte.
+ *
+ * @param node The string node to test
+ *
+ * @see mpack_node_str()
+ * @see mpack_node_strlen()
+ * @see mpack_node_copy_utf8_cstr()
+ * @see mpack_node_utf8_cstr_alloc()
+ */
+void mpack_node_check_utf8_cstr(mpack_node_t node);
+
+#if MPACK_EXTENSIONS
+/**
+ * Returns the extension type of the given ext node.
+ *
+ * This returns zero if the tree is in an error state.
+ *
+ * @note This requires @ref MPACK_EXTENSIONS.
+ */
+int8_t mpack_node_exttype(mpack_node_t node);
+#endif
+
+/**
+ * Returns the number of bytes in the given bin node.
+ *
+ * This returns zero if the tree is in an error state.
+ *
+ * If this node is not a bin, @ref mpack_error_type is raised and zero is returned.
+ */
+size_t mpack_node_bin_size(mpack_node_t node);
+
+/**
+ * Returns the length of the given str, bin or ext node.
+ *
+ * This returns zero if the tree is in an error state.
+ *
+ * If this node is not a str, bin or map, @ref mpack_error_type is raised and zero
+ * is returned.
+ */
+uint32_t mpack_node_data_len(mpack_node_t node);
+
+/**
+ * Returns the length in bytes of the given string node. This does not
+ * include any null-terminator.
+ *
+ * This returns zero if the tree is in an error state.
+ *
+ * If this node is not a str, @ref mpack_error_type is raised and zero is returned.
+ */
+size_t mpack_node_strlen(mpack_node_t node);
+
+/**
+ * Returns a pointer to the data contained by this node, ensuring the node is a
+ * string.
+ *
+ * @warning Strings are not null-terminated! Use one of the cstr functions
+ * to get a null-terminated string.
+ *
+ * The pointer is valid as long as the data backing the tree is valid.
+ *
+ * If this node is not a string, @ref mpack_error_type is raised and @c NULL is returned.
+ *
+ * @see mpack_node_copy_cstr()
+ * @see mpack_node_cstr_alloc()
+ * @see mpack_node_utf8_cstr_alloc()
+ */
+const char* mpack_node_str(mpack_node_t node);
+
+/**
+ * Returns a pointer to the data contained by this node.
+ *
+ * @note Strings are not null-terminated! Use one of the cstr functions
+ * to get a null-terminated string.
+ *
+ * The pointer is valid as long as the data backing the tree is valid.
+ *
+ * If this node is not of a str, bin or map, @ref mpack_error_type is raised, and
+ * @c NULL is returned.
+ *
+ * @see mpack_node_copy_cstr()
+ * @see mpack_node_cstr_alloc()
+ * @see mpack_node_utf8_cstr_alloc()
+ */
+const char* mpack_node_data(mpack_node_t node);
+
+/**
+ * Returns a pointer to the data contained by this bin node.
+ *
+ * The pointer is valid as long as the data backing the tree is valid.
+ *
+ * If this node is not a bin, @ref mpack_error_type is raised and @c NULL is
+ * returned.
+ */
+const char* mpack_node_bin_data(mpack_node_t node);
+
+/**
+ * Copies the bytes contained by this node into the given buffer, returning the
+ * number of bytes in the node.
+ *
+ * @throws mpack_error_type If this node is not a str, bin or ext type
+ * @throws mpack_error_too_big If the string does not fit in the given buffer
+ *
+ * @param node The string node from which to copy data
+ * @param buffer A buffer in which to copy the node's bytes
+ * @param bufsize The size of the given buffer
+ *
+ * @return The number of bytes in the node, or zero if an error occurs.
+ */
+size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize);
+
+/**
+ * Checks that the given node contains a valid UTF-8 string and copies the
+ * string into the given buffer, returning the number of bytes in the string.
+ *
+ * @throws mpack_error_type If this node is not a string
+ * @throws mpack_error_too_big If the string does not fit in the given buffer
+ *
+ * @param node The string node from which to copy data
+ * @param buffer A buffer in which to copy the node's bytes
+ * @param bufsize The size of the given buffer
+ *
+ * @return The number of bytes in the node, or zero if an error occurs.
+ */
+size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize);
+
+/**
+ * Checks that the given node contains a string with no NUL bytes, copies the string
+ * into the given buffer, and adds a null terminator.
+ *
+ * If this node is not of a string type, @ref mpack_error_type is raised. If the string
+ * does not fit, @ref mpack_error_data is raised.
+ *
+ * If any error occurs, the buffer will contain an empty null-terminated string.
+ *
+ * @param node The string node from which to copy data
+ * @param buffer A buffer in which to copy the node's string
+ * @param size The size of the given buffer
+ */
+void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t size);
+
+/**
+ * Checks that the given node contains a valid UTF-8 string with no NUL bytes,
+ * copies the string into the given buffer, and adds a null terminator.
+ *
+ * If this node is not of a string type, @ref mpack_error_type is raised. If the string
+ * does not fit, @ref mpack_error_data is raised.
+ *
+ * If any error occurs, the buffer will contain an empty null-terminated string.
+ *
+ * @param node The string node from which to copy data
+ * @param buffer A buffer in which to copy the node's string
+ * @param size The size of the given buffer
+ */
+void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t size);
+
+#ifdef MPACK_MALLOC
+/**
+ * Allocates a new chunk of data using MPACK_MALLOC() with the bytes
+ * contained by this node.
+ *
+ * The allocated data must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_type If this node is not a str, bin or ext type
+ * @throws mpack_error_too_big If the size of the data is larger than the
+ *     given maximum size
+ * @throws mpack_error_memory If an allocation failure occurs
+ *
+ * @param node The node from which to allocate and copy data
+ * @param maxsize The maximum size to allocate
+ *
+ * @return The allocated data, or NULL if any error occurs.
+ */
+char* mpack_node_data_alloc(mpack_node_t node, size_t maxsize);
+
+/**
+ * Allocates a new null-terminated string using MPACK_MALLOC() with the string
+ * contained by this node.
+ *
+ * The allocated string must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_type If this node is not a string or contains NUL bytes
+ * @throws mpack_error_too_big If the size of the string plus null-terminator
+ *     is larger than the given maximum size
+ * @throws mpack_error_memory If an allocation failure occurs
+ *
+ * @param node The node from which to allocate and copy string data
+ * @param maxsize The maximum size to allocate, including the null-terminator
+ *
+ * @return The allocated string, or NULL if any error occurs.
+ */
+char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxsize);
+
+/**
+ * Allocates a new null-terminated string using MPACK_MALLOC() with the UTF-8
+ * string contained by this node.
+ *
+ * The allocated string must be freed with MPACK_FREE() (or simply free()
+ * if MPack's allocator hasn't been customized.)
+ *
+ * @throws mpack_error_type If this node is not a string, is not valid UTF-8,
+ *     or contains NUL bytes
+ * @throws mpack_error_too_big If the size of the string plus null-terminator
+ *     is larger than the given maximum size
+ * @throws mpack_error_memory If an allocation failure occurs
+ *
+ * @param node The node from which to allocate and copy string data
+ * @param maxsize The maximum size to allocate, including the null-terminator
+ *
+ * @return The allocated string, or NULL if any error occurs.
+ */
+char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxsize);
+#endif
+
+/**
+ * Searches the given string array for a string matching the given
+ * node and returns its index.
+ *
+ * If the node does not match any of the given strings,
+ * @ref mpack_error_type is flagged. Use mpack_node_enum_optional()
+ * if you want to allow values other than the given strings.
+ *
+ * If any error occurs or if the tree is in an error state, @a count
+ * is returned.
+ *
+ * This can be used to quickly parse a string into an enum when the
+ * enum values range from 0 to @a count-1. If the last value in the
+ * enum is a special "count" value, it can be passed as the count,
+ * and the return value can be cast directly to the enum type.
+ *
+ * @code{.c}
+ * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
+ * const char* fruits[] = {"apple", "banana", "orange"};
+ *
+ * fruit_t fruit = (fruit_t)mpack_node_enum(node, fruits, COUNT);
+ * @endcode
+ *
+ * @param node The node
+ * @param strings An array of expected strings of length count
+ * @param count The number of strings
+ * @return The index of the matched string, or @a count in case of error
+ */
+size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count);
+
+/**
+ * Searches the given string array for a string matching the given node,
+ * returning its index or @a count if no strings match.
+ *
+ * If the value is not a string, or it does not match any of the
+ * given strings, @a count is returned and no error is flagged.
+ *
+ * If any error occurs or if the tree is in an error state, @a count
+ * is returned.
+ *
+ * This can be used to quickly parse a string into an enum when the
+ * enum values range from 0 to @a count-1. If the last value in the
+ * enum is a special "count" value, it can be passed as the count,
+ * and the return value can be cast directly to the enum type.
+ *
+ * @code{.c}
+ * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
+ * const char* fruits[] = {"apple", "banana", "orange"};
+ *
+ * fruit_t fruit = (fruit_t)mpack_node_enum_optional(node, fruits, COUNT);
+ * @endcode
+ *
+ * @param node The node
+ * @param strings An array of expected strings of length count
+ * @param count The number of strings
+ * @return The index of the matched string, or @a count in case of error
+ */
+size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count);
+
+/**
+ * @}
+ */
+
+/**
+ * @name Compound Node Functions
+ * @{
+ */
+
+/**
+ * Returns the length of the given array node. Raises mpack_error_type
+ * and returns 0 if the given node is not an array.
+ */
+size_t mpack_node_array_length(mpack_node_t node);
+
+/**
+ * Returns the node in the given array at the given index. If the node
+ * is not an array, @ref mpack_error_type is raised and a nil node is returned.
+ * If the given index is out of bounds, @ref mpack_error_data is raised and
+ * a nil node is returned.
+ */
+mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index);
+
+/**
+ * Returns the number of key/value pairs in the given map node. Raises
+ * mpack_error_type and returns 0 if the given node is not a map.
+ */
+size_t mpack_node_map_count(mpack_node_t node);
+
+/**
+ * Returns the key node in the given map at the given index.
+ *
+ * A nil node is returned in case of error.
+ *
+ * @throws mpack_error_type if the node is not a map
+ * @throws mpack_error_data if the given index is out of bounds
+ */
+mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index);
+
+/**
+ * Returns the value node in the given map at the given index.
+ *
+ * A nil node is returned in case of error.
+ *
+ * @throws mpack_error_type if the node is not a map
+ * @throws mpack_error_data if the given index is out of bounds
+ */
+mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index);
+
+/**
+ * Returns the value node in the given map for the given integer key.
+ *
+ * The key must exist within the map. Use mpack_node_map_int_optional() to
+ * check for optional keys.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node does not contain exactly one entry with the given key
+ *
+ * @return The value node for the given key, or a nil node in case of error
+ */
+mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num);
+
+/**
+ * Returns the value node in the given map for the given integer key, or a
+ * missing node if the map does not contain the given key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ *
+ * @return The value node for the given key, or a missing node if the key does
+ *         not exist, or a nil node in case of error
+ *
+ * @see mpack_node_is_missing()
+ */
+mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num);
+
+/**
+ * Returns the value node in the given map for the given unsigned integer key.
+ *
+ * The key must exist within the map. Use mpack_node_map_uint_optional() to
+ * check for optional keys.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node does not contain exactly one entry with the given key
+ *
+ * @return The value node for the given key, or a nil node in case of error
+ */
+mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num);
+
+/**
+ * Returns the value node in the given map for the given unsigned integer
+ * key, or a missing node if the map does not contain the given key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ *
+ * @return The value node for the given key, or a missing node if the key does
+ *         not exist, or a nil node in case of error
+ *
+ * @see mpack_node_is_missing()
+ */
+mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num);
+
+/**
+ * Returns the value node in the given map for the given string key.
+ *
+ * The key must exist within the map. Use mpack_node_map_str_optional() to
+ * check for optional keys.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node does not contain exactly one entry with the given key
+ *
+ * @return The value node for the given key, or a nil node in case of error
+ */
+mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length);
+
+/**
+ * Returns the value node in the given map for the given string key, or a missing
+ * node if the map does not contain the given key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ *
+ * @return The value node for the given key, or a missing node if the key does
+ *         not exist, or a nil node in case of error
+ *
+ * @see mpack_node_is_missing()
+ */
+mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length);
+
+/**
+ * Returns the value node in the given map for the given null-terminated
+ * string key.
+ *
+ * The key must exist within the map. Use mpack_node_map_cstr_optional() to
+ * check for optional keys.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node does not contain exactly one entry with the given key
+ *
+ * @return The value node for the given key, or a nil node in case of error
+ */
+mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr);
+
+/**
+ * Returns the value node in the given map for the given null-terminated
+ * string key, or a missing node if the map does not contain the given key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ *
+ * @return The value node for the given key, or a missing node if the key does
+ *         not exist, or a nil node in case of error
+ *
+ * @see mpack_node_is_missing()
+ */
+mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr);
+
+/**
+ * Returns true if the given node map contains exactly one entry with the
+ * given integer key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ */
+bool mpack_node_map_contains_int(mpack_node_t node, int64_t num);
+
+/**
+ * Returns true if the given node map contains exactly one entry with the
+ * given unsigned integer key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ */
+bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num);
+
+/**
+ * Returns true if the given node map contains exactly one entry with the
+ * given string key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ */
+bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length);
+
+/**
+ * Returns true if the given node map contains exactly one entry with the
+ * given null-terminated string key.
+ *
+ * The key must be unique. An error is flagged if the node has multiple
+ * entries with the given key.
+ *
+ * @throws mpack_error_type If the node is not a map
+ * @throws mpack_error_data If the node contains more than one entry with the given key
+ */
+bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr);
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+#endif
+
+MPACK_EXTERN_C_END
+MPACK_HEADER_END
+
+#endif
+
+
+#endif
+
diff --git a/fluent-bit/lib/ctraces/markdownlint.rb b/fluent-bit/lib/ctraces/markdownlint.rb
new file mode 100644
index 000000000..598a9b5b6
--- /dev/null
+++ b/fluent-bit/lib/ctraces/markdownlint.rb
@@ -0,0 +1,16 @@
+#!/usr/bin/ruby
+
+# Enable all rules by default
+all
+
+# Extend line length, since each sentence should be on a separate line.
+rule 'MD013', :line_length => 99999, :ignore_code_blocks => true
+
+# Allow in-line HTML
+exclude_rule 'MD033'
+
+# Nested lists should be indented with two spaces.
+rule 'MD007', :indent => 2
+
+# Bash defaulting confuses this and now way to ignore code blocks
+exclude_rule 'MD029'
diff --git a/fluent-bit/lib/ctraces/scripts/win_build.bat b/fluent-bit/lib/ctraces/scripts/win_build.bat
new file mode 100755
index 000000000..3de4baa7f
--- /dev/null
+++ b/fluent-bit/lib/ctraces/scripts/win_build.bat
@@ -0,0 +1,8 @@
+setlocal
+call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\Tools\VsDevCmd.bat"
+path "C:\Program Files (x86)\MSBuild\16.0\Bin;C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin";%path%
+git submodule update --init --recursive
+cd build
+cmake -G "NMake Makefiles"  -DCTR_TESTS=On ..\
+cmake --build .
+endlocal
diff --git a/fluent-bit/lib/ctraces/src/CMakeLists.txt b/fluent-bit/lib/ctraces/src/CMakeLists.txt
new file mode 100644
index 000000000..5a6392464
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/CMakeLists.txt
@@ -0,0 +1,39 @@
+set(src
+  ctraces.c
+  ctr_resource.c
+  ctr_span.c
+  ctr_link.c
+  ctr_scope.c
+  ctr_log.c
+  ctr_id.c
+  ctr_random.c
+  ctr_utils.c
+  ctr_attributes.c
+  ctr_version.c
+  ctr_mpack_utils.c
+  # encoders
+  ctr_encode_text.c
+  ctr_encode_msgpack.c
+  ctr_encode_opentelemetry.c
+  # decoders
+  ctr_decode_msgpack.c
+  ctr_decode_opentelemetry.c
+  )
+
+# Static Library
+add_library(ctraces-static STATIC ${src})
+target_link_libraries(ctraces-static mpack-static cfl-static fluent-otel-proto)
+
+# Install Library
+if(MSVC)
+  # Rename the output for Windows environment to avoid naming issues
+  set_target_properties(ctraces-static PROPERTIES OUTPUT_NAME libctraces)
+else()
+  set_target_properties(ctraces-static PROPERTIES OUTPUT_NAME ctraces)
+endif(MSVC)
+
+install(TARGETS ctraces-static
+  RUNTIME DESTINATION ${CTR_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CTR_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CTR_INSTALL_LIBDIR}
+  COMPONENT library)
diff --git a/fluent-bit/lib/ctraces/src/ctr_attributes.c b/fluent-bit/lib/ctraces/src/ctr_attributes.c
new file mode 100644
index 000000000..44bb13853
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_attributes.c
@@ -0,0 +1,88 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+struct ctrace_attributes *ctr_attributes_create()
+{
+    struct ctrace_attributes *attr;
+
+    attr = malloc(sizeof(struct ctrace_attributes));
+    if (!attr) {
+        ctr_errno();
+        return NULL;
+    }
+
+    attr->kv = cfl_kvlist_create(128);
+    if (!attr->kv) {
+        free(attr);
+        return NULL;
+    }
+
+    return attr;
+}
+
+void ctr_attributes_destroy(struct ctrace_attributes *attr)
+{
+    if (attr->kv) {
+        cfl_kvlist_destroy(attr->kv);
+    }
+    free(attr);
+}
+
+int ctr_attributes_count(struct ctrace_attributes *attr)
+{
+    return cfl_kvlist_count(attr->kv);
+}
+
+int ctr_attributes_set_string(struct ctrace_attributes *attr, char *key, char *value)
+{
+    return cfl_kvlist_insert_string(attr->kv, key, value);
+}
+
+int ctr_attributes_set_bool(struct ctrace_attributes *attr, char *key, int b)
+{
+    if (b != CTR_TRUE && b != CTR_FALSE) {
+        return -1;
+    }
+
+    return cfl_kvlist_insert_bool(attr->kv, key, b);
+}
+
+int ctr_attributes_set_int64(struct ctrace_attributes *attr, char *key, int64_t value)
+{
+    return cfl_kvlist_insert_int64(attr->kv, key, value);
+}
+
+int ctr_attributes_set_double(struct ctrace_attributes *attr, char *key, double value)
+{
+    return cfl_kvlist_insert_double(attr->kv, key, value);
+}
+
+int ctr_attributes_set_array(struct ctrace_attributes *attr, char *key,
+                             struct cfl_array *value)
+{
+    return cfl_kvlist_insert_array(attr->kv, key, value);
+}
+
+int ctr_attributes_set_kvlist(struct ctrace_attributes *attr, char *key,
+                              struct cfl_kvlist *value)
+{
+    return cfl_kvlist_insert_kvlist(attr->kv, key, value);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_decode_msgpack.c b/fluent-bit/lib/ctraces/src/ctr_decode_msgpack.c
new file mode 100644
index 000000000..f1df5c325
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_decode_msgpack.c
@@ -0,0 +1,715 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_mpack_utils.h>
+#include <ctraces/ctr_decode_msgpack.h>
+#include <cfl/cfl_sds.h>
+#include <ctraces/ctr_variant_utils.h>
+
+
+/* Resource callbacks */
+
+static int unpack_resource_dropped_attributes_count(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint32_tag(
+            reader, &context->resource->dropped_attr_count);
+}
+
+static int unpack_resource_attributes(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct cfl_kvlist                 *attributes;
+    int                                result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        result = ctr_mpack_consume_nil_tag(reader);
+    }
+    else {
+        result = unpack_cfl_kvlist(reader, &attributes);
+
+        if (result == 0) {
+            cfl_kvlist_destroy(context->resource->attr->kv);
+
+            context->resource->attr->kv = attributes;
+        }
+    }
+
+    return result;
+}
+
+static int unpack_resource(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"attributes",               unpack_resource_attributes},
+            {"dropped_attributes_count", unpack_resource_dropped_attributes_count},
+            {NULL,                       NULL}
+        };
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+
+/* Instrumentation scope callbacks */
+
+static int unpack_instrumentation_scope_name(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_string_or_nil_tag(
+            reader,
+            &context->scope_span->instrumentation_scope->name);
+}
+
+static int unpack_instrumentation_scope_version(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_string_or_nil_tag(
+            reader,
+            &context->scope_span->instrumentation_scope->version);
+}
+
+static int unpack_instrumentation_scope_dropped_attribute_count(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint32_tag(
+            reader,
+            &context->scope_span->instrumentation_scope->dropped_attr_count);
+}
+
+static int unpack_instrumentation_scope_attributes(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct ctrace_attributes          *attributes;
+    int                                result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        result = ctr_mpack_consume_nil_tag(reader);
+    }
+    else {
+        attributes = ctr_attributes_create();
+        if (attributes == NULL) {
+            return CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR;
+        }
+
+        cfl_kvlist_destroy(attributes->kv);
+
+        attributes->kv = NULL;
+
+        result = unpack_cfl_kvlist(reader, &attributes->kv);
+
+        if (result != 0) {
+            ctr_attributes_destroy(attributes);
+            return CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR;
+        }
+
+        context->scope_span->instrumentation_scope->attr = attributes;
+    }
+
+    return CTR_DECODE_MSGPACK_SUCCESS;
+}
+
+static int unpack_scope_span_instrumentation_scope(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctrace_instrumentation_scope  *instrumentation_scope;
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"name",                     unpack_instrumentation_scope_name},
+            {"version",                  unpack_instrumentation_scope_version},
+            {"attributes",               unpack_instrumentation_scope_attributes},
+            {"dropped_attributes_count", unpack_instrumentation_scope_dropped_attribute_count},
+            {NULL,                       NULL}
+        };
+
+    instrumentation_scope = ctr_instrumentation_scope_create(NULL, NULL, 0, NULL);
+
+    if (instrumentation_scope == NULL) {
+        return CTR_DECODE_MSGPACK_ALLOCATION_ERROR;
+    }
+
+    ctr_scope_span_set_instrumentation_scope(context->scope_span, instrumentation_scope);
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Event callbacks */
+
+static int unpack_event_name(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    if (context->event->name != NULL) {
+        cfl_sds_destroy(context->event->name);
+
+        context->event->name = NULL;
+    }
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->event->name);
+}
+
+static int unpack_event_time_unix_nano(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint64_tag(reader, &context->event->time_unix_nano);
+}
+
+static int unpack_event_attributes(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct cfl_kvlist                 *attributes;
+    int                                result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        ctr_mpack_consume_nil_tag(reader);
+
+        return CTR_DECODE_MSGPACK_SUCCESS;
+    }
+
+    result = unpack_cfl_kvlist(reader, &attributes);
+
+    if (result != 0) {
+        return CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR;
+    }
+
+    cfl_kvlist_destroy(context->event->attr->kv);
+    context->event->attr->kv = attributes;
+
+    return CTR_DECODE_MSGPACK_SUCCESS;
+}
+
+static int unpack_event_dropped_attributes_count(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint32_tag(reader, &context->event->dropped_attr_count);
+}
+
+static int unpack_event(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"name",                     unpack_event_name},
+            {"time_unix_nano",           unpack_event_time_unix_nano},
+            {"attributes",               unpack_event_attributes},
+            {"dropped_attributes_count", unpack_event_dropped_attributes_count},
+            {NULL,                       NULL}
+        };
+
+    context->event = ctr_span_event_add(context->span, "");
+
+    if (context->event == NULL) {
+        return CTR_DECODE_MSGPACK_ALLOCATION_ERROR;
+    }
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Link callbacks */
+
+static int unpack_link_trace_id(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    int                                result;
+    cfl_sds_t                          value;
+
+    result = ctr_mpack_consume_string_or_nil_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS && value != NULL) {
+        context->link->trace_id = ctr_id_from_base16(value);
+
+        if (context->link->trace_id == NULL) {
+            result = CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+        }
+
+        cfl_sds_destroy(value);
+    }
+
+    return result;
+}
+
+static int unpack_link_span_id(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    int                                result;
+    cfl_sds_t                          value;
+
+    result = ctr_mpack_consume_string_or_nil_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS && value != NULL) {
+        context->link->span_id = ctr_id_from_base16(value);
+
+        if (context->link->span_id == NULL) {
+            result = CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+        }
+
+        cfl_sds_destroy(value);
+    }
+
+    return result;
+}
+
+static int unpack_link_trace_state(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->link->trace_state);
+}
+
+static int unpack_link_dropped_attributes_count(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint32_tag(reader, &context->link->dropped_attr_count);
+}
+
+static int unpack_link_attributes(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct cfl_kvlist                 *attributes;
+    int                                result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        result = ctr_mpack_consume_nil_tag(reader);
+    }
+    else {
+        result = unpack_cfl_kvlist(reader, &attributes);
+
+        if (result == 0) {
+            if (context->link->attr == NULL) {
+                context->link->attr = ctr_attributes_create();
+            }
+
+            if (context->link->attr->kv != NULL) {
+                cfl_kvlist_destroy(context->link->attr->kv);
+            }
+
+            context->link->attr->kv = attributes;
+
+            result = CTR_DECODE_MSGPACK_SUCCESS;
+        }
+        else {
+            result = CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR;
+        }
+    }
+
+    return result;
+}
+
+static int unpack_link(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"trace_id",                 unpack_link_trace_id},
+            {"span_id",                  unpack_link_span_id},
+            {"trace_state",              unpack_link_trace_state},
+            {"attributes",               unpack_link_attributes},
+            {"dropped_attributes_count", unpack_link_dropped_attributes_count},
+            {NULL,                       NULL}
+        };
+
+    context->link = ctr_link_create(context->span, NULL, 0, NULL, 0);
+
+    if (context->link == NULL) {
+        return CTR_MPACK_ALLOCATION_ERROR;
+    }
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Span callbacks */
+
+static int unpack_span_trace_id(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct ctrace_id                  *decoded_id;
+    int                                result;
+    cfl_sds_t                          value;
+
+    result = ctr_mpack_consume_string_or_nil_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS && value != NULL) {
+        decoded_id = ctr_id_from_base16(value);
+
+        if (decoded_id != NULL) {
+            ctr_span_set_trace_id_with_cid(context->span, decoded_id);
+
+            ctr_id_destroy(decoded_id);
+        }
+        else {
+            result = CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+        }
+
+        cfl_sds_destroy(value);
+    }
+
+    return result;
+}
+
+static int unpack_span_span_id(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct ctrace_id                  *decoded_id;
+    int                                result;
+    cfl_sds_t                          value;
+
+    result = ctr_mpack_consume_string_or_nil_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS && value != NULL) {
+        decoded_id = ctr_id_from_base16(value);
+
+        if (decoded_id != NULL) {
+            ctr_span_set_span_id_with_cid(context->span, decoded_id);
+
+            ctr_id_destroy(decoded_id);
+        }
+        else {
+            result = CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+        }
+
+        cfl_sds_destroy(value);
+    }
+
+    return result;
+}
+
+static int unpack_span_parent_span_id(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct ctrace_id                  *decoded_id;
+    int                                result;
+    cfl_sds_t                          value;
+
+    result = ctr_mpack_consume_string_or_nil_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS && value != NULL) {
+        decoded_id = ctr_id_from_base16(value);
+
+        if (decoded_id != NULL) {
+            ctr_span_set_parent_span_id_with_cid(context->span, decoded_id);
+
+            ctr_id_destroy(decoded_id);
+        }
+        else {
+            result = CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+        }
+
+        cfl_sds_destroy(value);
+    }
+
+    return result;
+}
+
+static int unpack_span_trace_state(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    if (context->span->trace_state != NULL) {
+        cfl_sds_destroy(context->span->trace_state);
+
+        context->span->trace_state = NULL;
+    }
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->span->trace_state);
+}
+
+static int unpack_span_name(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    if (context->span->name != NULL) {
+        cfl_sds_destroy(context->span->name);
+
+        context->span->name = NULL;
+    }
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->span->name);
+}
+
+static int unpack_span_kind(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_int32_tag(reader, &context->span->kind);
+}
+
+static int unpack_span_start_time_unix_nano(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint64_tag(reader, &context->span->start_time_unix_nano);
+}
+
+static int unpack_span_end_time_unix_nano(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint64_tag(reader, &context->span->end_time_unix_nano);
+}
+
+static int unpack_span_attributes(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+    struct cfl_kvlist                 *attributes;
+    int                                result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        ctr_mpack_consume_nil_tag(reader);
+
+        return CTR_DECODE_MSGPACK_SUCCESS;
+    }
+
+    result = unpack_cfl_kvlist(reader, &attributes);
+
+    if (result != 0) {
+        return CTR_DECODE_MSGPACK_VARIANT_DECODE_ERROR;
+    }
+
+    cfl_kvlist_destroy(context->span->attr->kv);
+    context->span->attr->kv = attributes;
+
+    return CTR_DECODE_MSGPACK_SUCCESS;
+}
+
+static int unpack_span_dropped_attributes_count(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_uint32_tag(reader, &context->span->dropped_attr_count);
+}
+
+static int unpack_span_events(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    return ctr_mpack_unpack_array(reader, unpack_event, ctx);
+}
+
+
+static int unpack_span_links(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    return ctr_mpack_unpack_array(reader, unpack_link, ctx);
+}
+
+static int unpack_span_status_code(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_int32_tag(reader, &context->span->status.code);
+}
+
+static int unpack_span_status_message(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->span->status.message);
+}
+
+static int unpack_span_status(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"code",    unpack_span_status_code},
+            {"message", unpack_span_status_message},
+            {NULL,      NULL}
+        };
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+static int unpack_span(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"trace_id",                 unpack_span_trace_id},
+            {"span_id",                  unpack_span_span_id},
+            {"parent_span_id",           unpack_span_parent_span_id},
+            {"trace_state",              unpack_span_trace_state},
+            {"name",                     unpack_span_name},
+            {"kind",                     unpack_span_kind},
+            {"start_time_unix_nano",     unpack_span_start_time_unix_nano},
+            {"end_time_unix_nano",       unpack_span_end_time_unix_nano},
+            {"attributes",               unpack_span_attributes},
+            {"dropped_attributes_count", unpack_span_dropped_attributes_count},
+            {"events",                   unpack_span_events},
+            {"links",                    unpack_span_links},
+            {"status",                   unpack_span_status},
+            {NULL,                       NULL}
+        };
+
+    context->span = ctr_span_create(context->trace, context->scope_span, "", NULL);
+
+    if (context->span == NULL) {
+        return CTR_DECODE_MSGPACK_ALLOCATION_ERROR;
+    }
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Scope span callbacks */
+
+static int unpack_scope_span_spans(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    return ctr_mpack_unpack_array(reader, unpack_span, ctx);
+}
+
+static int unpack_scope_span_schema_url(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    if (context->scope_span->schema_url != NULL) {
+        cfl_sds_destroy(context->scope_span->schema_url);
+
+        context->scope_span->schema_url = NULL;
+    }
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->scope_span->schema_url);
+}
+
+static int unpack_scope_span(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"scope",      unpack_scope_span_instrumentation_scope},
+            {"spans",      unpack_scope_span_spans},
+            {"schema_url", unpack_scope_span_schema_url},
+            {NULL,         NULL}
+        };
+
+    context->scope_span = ctr_scope_span_create(context->resource_span);
+
+    if (context->scope_span == NULL) {
+        return CTR_DECODE_MSGPACK_ALLOCATION_ERROR;
+    }
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Resource span callbacks */
+
+static int unpack_resource_span_scope_spans(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    return ctr_mpack_unpack_array(reader, unpack_scope_span, ctx);
+}
+
+static int unpack_resource_span_schema_url(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context *context = ctx;
+
+    if (context->resource_span->schema_url != NULL) {
+        cfl_sds_destroy(context->resource_span->schema_url);
+
+        context->resource_span->schema_url = NULL;
+    }
+
+    return ctr_mpack_consume_string_or_nil_tag(reader, &context->resource_span->schema_url);
+}
+
+static int unpack_resource_span(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    struct ctr_msgpack_decode_context    *context = ctx;
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"resource",    unpack_resource},
+            {"schema_url",  unpack_resource_span_schema_url},
+            {"scope_spans", unpack_resource_span_scope_spans},
+            {NULL,          NULL}
+        };
+
+    context->resource_span = ctr_resource_span_create(context->trace);
+
+    if (context->resource_span == NULL) {
+        return CTR_DECODE_MSGPACK_ALLOCATION_ERROR;
+    }
+
+    context->resource = context->resource_span->resource;
+
+    return ctr_mpack_unpack_map(reader, callbacks, ctx);
+}
+
+/* Outermost block callbacks*/
+
+static int unpack_resource_spans(mpack_reader_t *reader, size_t index, void *ctx)
+{
+    return ctr_mpack_unpack_array(reader, unpack_resource_span, ctx);
+}
+
+static int unpack_context(mpack_reader_t *reader, struct ctr_msgpack_decode_context *ctx)
+{
+    struct ctr_mpack_map_entry_callback_t callbacks[] = \
+        {
+            {"resourceSpans", unpack_resource_spans},
+            {NULL,            NULL}
+        };
+
+    return ctr_mpack_unpack_map(reader, callbacks, (void *) ctx);
+}
+
+int ctr_decode_msgpack_create(struct ctrace **out_context, char *in_buf, size_t in_size, size_t *offset)
+{
+    size_t                            remainder;
+    struct ctr_msgpack_decode_context context;
+    mpack_reader_t                    reader;
+    int                               result;
+
+    memset(&context, 0, sizeof(context));
+
+    context.trace = ctr_create(NULL);
+
+    if (context.trace == NULL) {
+        return -1;
+    }
+
+    in_size -= *offset;
+
+    mpack_reader_init_data(&reader, &in_buf[*offset], in_size);
+
+    result = unpack_context(&reader, &context);
+
+    remainder = mpack_reader_remaining(&reader, NULL);
+
+    *offset += in_size - remainder;
+
+    mpack_reader_destroy(&reader);
+
+    if (result != CTR_DECODE_MSGPACK_SUCCESS) {
+        ctr_destroy(context.trace);
+
+        context.trace = NULL;
+    }
+
+    *out_context = context.trace;
+
+    return result;
+}
+
+void ctr_decode_msgpack_destroy(struct ctrace *context)
+{
+    if (context != NULL) {
+        ctr_destroy(context);
+    }
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_decode_opentelemetry.c b/fluent-bit/lib/ctraces/src/ctr_decode_opentelemetry.c
new file mode 100644
index 000000000..139ae2cd9
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_decode_opentelemetry.c
@@ -0,0 +1,593 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include <cfl/cfl_array.h>
+#include <fluent-otel-proto/fluent-otel.h>
+
+static int convert_any_value(struct opentelemetry_decode_value *ctr_val,
+                             opentelemetry_decode_value_type value_type, char *key,
+                             Opentelemetry__Proto__Common__V1__AnyValue *val);
+
+static int convert_string_value(struct opentelemetry_decode_value *ctr_val,
+                                opentelemetry_decode_value_type value_type,
+                                char *key, char *val)
+{
+    int result;
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_string(ctr_val->ctr_attr, key, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_string(ctr_val->cfl_arr, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_string(ctr_val->cfl_kvlist, key, val);
+            break;
+
+    }
+
+    if (result == -2) {
+        printf("convert_string_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_bool_value(struct opentelemetry_decode_value *ctr_val,
+                              opentelemetry_decode_value_type value_type,
+                              char *key, protobuf_c_boolean val)
+{
+    int result;
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_bool(ctr_val->ctr_attr, key, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_bool(ctr_val->cfl_arr, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_bool(ctr_val->cfl_kvlist, key, val);
+            break;
+
+    }
+
+    if (result == -2) {
+        printf("convert_bool_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_int_value(struct opentelemetry_decode_value *ctr_val,
+                             opentelemetry_decode_value_type value_type,
+                             char *key, int64_t val)
+{
+    int result;
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_int64(ctr_val->ctr_attr, key, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_int64(ctr_val->cfl_arr, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_int64(ctr_val->cfl_kvlist, key, val);
+            break;
+
+    }
+
+    if (result == -2) {
+        printf("convert_int_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_double_value(struct opentelemetry_decode_value *ctr_val,
+                                opentelemetry_decode_value_type value_type,
+                                char *key, double val)
+{
+    int result;
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_double(ctr_val->ctr_attr, key, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_double(ctr_val->cfl_arr, val);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_double(ctr_val->cfl_kvlist, key, val);
+            break;
+
+    }
+
+    if (result == -2) {
+        printf("convert_double_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_array_value(struct opentelemetry_decode_value *ctr_val,
+                               opentelemetry_decode_value_type value_type,
+                               char *key, Opentelemetry__Proto__Common__V1__ArrayValue *otel_arr)
+{
+    int array_index;
+    int result;
+    struct opentelemetry_decode_value *ctr_arr_val;
+    Opentelemetry__Proto__Common__V1__AnyValue *val;
+
+    ctr_arr_val = malloc(sizeof(struct opentelemetry_decode_value));
+    if (!ctr_arr_val) {
+        ctr_errno();
+        return -1;
+    }
+    ctr_arr_val->cfl_arr = cfl_array_create(otel_arr->n_values);
+
+    result = 0;
+
+    for (array_index = 0;
+         array_index < otel_arr->n_values && result == 0;
+         array_index++) {
+        val = otel_arr->values[array_index];
+        result = convert_any_value(ctr_arr_val, CTR_OPENTELEMETRY_TYPE_ARRAY, NULL, val);
+    }
+
+    if (result < 0) {
+        cfl_array_destroy(ctr_arr_val->cfl_arr);
+        free(ctr_arr_val);
+        return result;
+    }
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_array(ctr_val->ctr_attr, key, ctr_arr_val->cfl_arr);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_array(ctr_val->cfl_arr, ctr_arr_val->cfl_arr);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_array(ctr_val->cfl_kvlist, key, ctr_arr_val->cfl_arr);
+            break;
+
+    }
+
+    free(ctr_arr_val);
+    if (result == -2) {
+        fprintf(stderr, "convert_array_value: unknown value type\n");
+    }
+
+    return result;
+}
+
+static int convert_kvlist_value(struct opentelemetry_decode_value *ctr_val,
+                                opentelemetry_decode_value_type value_type,
+                                char *key, Opentelemetry__Proto__Common__V1__KeyValueList *otel_kvlist)
+{
+    int kvlist_index;
+    int result;
+    struct opentelemetry_decode_value *ctr_kvlist_val;
+    Opentelemetry__Proto__Common__V1__KeyValue *kv;
+
+    ctr_kvlist_val = malloc(sizeof(struct opentelemetry_decode_value));
+    if (!ctr_kvlist_val) {
+        ctr_errno();
+        return -1;
+    }
+    ctr_kvlist_val->cfl_kvlist = cfl_kvlist_create();
+
+    result = 0;
+    for (kvlist_index = 0;
+         kvlist_index < otel_kvlist->n_values && result ==0;
+         kvlist_index++) {
+
+        kv = otel_kvlist->values[kvlist_index];
+        result = convert_any_value(ctr_kvlist_val, CTR_OPENTELEMETRY_TYPE_KVLIST, kv->key, kv->value);
+    }
+
+    if (result < 0){
+        cfl_kvlist_destroy(ctr_kvlist_val->cfl_kvlist);
+        free(ctr_kvlist_val);
+        return result;
+    }
+
+    result = -2;
+
+    switch (value_type) {
+
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = ctr_attributes_set_kvlist(ctr_val->ctr_attr, key, ctr_kvlist_val->cfl_kvlist);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_kvlist(ctr_val->cfl_arr, ctr_kvlist_val->cfl_kvlist);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_kvlist(ctr_val->cfl_kvlist, key, ctr_kvlist_val->cfl_kvlist);
+            break;
+
+    }
+
+    free(ctr_kvlist_val);
+
+    if (result == -2) {
+        printf("convert_kvlist_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_bytes_value(struct opentelemetry_decode_value *ctr_val,
+                               opentelemetry_decode_value_type value_type,
+                               char *key, void *buf, size_t len)
+{
+    int result;
+
+    result = -2;
+
+    switch (value_type) {
+        case CTR_OPENTELEMETRY_TYPE_ATTRIBUTE:
+            result = -1;
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_ARRAY:
+            result = cfl_array_append_bytes(ctr_val->cfl_arr, buf, len);
+            break;
+
+        case CTR_OPENTELEMETRY_TYPE_KVLIST:
+            result = cfl_kvlist_insert_bytes(ctr_val->cfl_kvlist, key, buf, len);
+            break;
+
+    }
+
+    if (result == -2) {
+        printf("convert_bytes_value: unknown value type");
+    }
+
+    return result;
+}
+
+static int convert_any_value(struct opentelemetry_decode_value *ctr_val,
+                             opentelemetry_decode_value_type value_type, char *key,
+                             Opentelemetry__Proto__Common__V1__AnyValue *val)
+{
+    int result;
+
+    switch (val->value_case) {
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE:
+            result = convert_string_value(ctr_val, value_type, key, val->string_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BOOL_VALUE:
+            result = convert_bool_value(ctr_val, value_type, key, val->bool_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_INT_VALUE:
+            result = convert_int_value(ctr_val, value_type, key, val->int_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_DOUBLE_VALUE:
+            result = convert_double_value(ctr_val, value_type, key, val->double_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_ARRAY_VALUE:
+            result = convert_array_value(ctr_val, value_type, key, val->array_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_KVLIST_VALUE:
+            result = convert_kvlist_value(ctr_val, value_type, key, val->kvlist_value);
+            break;
+
+        case OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BYTES_VALUE:
+            result = convert_bytes_value(ctr_val, value_type, key, val->bytes_value.data, val->bytes_value.len);
+            break;
+
+        default:
+            result = -1;
+            break;
+        }
+
+    return result;
+}
+
+static struct ctrace_attributes *convert_otel_attrs(size_t n_attributes,
+                                                    Opentelemetry__Proto__Common__V1__KeyValue **otel_attr)
+{
+    int index_kv;
+    int result;
+    char *key;
+    struct opentelemetry_decode_value *ctr_decoded_attributes;
+    struct ctrace_attributes *attr;
+
+    Opentelemetry__Proto__Common__V1__KeyValue *kv;
+    Opentelemetry__Proto__Common__V1__AnyValue *val;
+
+    ctr_decoded_attributes = malloc(sizeof(struct opentelemetry_decode_value));
+    ctr_decoded_attributes->ctr_attr = ctr_attributes_create();
+
+    result = 0;
+
+    for (index_kv = 0; index_kv < n_attributes && result == 0; index_kv++) {
+        kv = otel_attr[index_kv];
+
+        key = kv->key;
+        val = kv->value;
+
+        result = convert_any_value(ctr_decoded_attributes,
+                                       CTR_OPENTELEMETRY_TYPE_ATTRIBUTE,
+                                       key, val);
+    }
+
+    if (result < 0) {
+        ctr_attributes_destroy(ctr_decoded_attributes->ctr_attr);
+        free(ctr_decoded_attributes);
+        return NULL;
+    }
+
+    attr = ctr_decoded_attributes->ctr_attr;
+    free(ctr_decoded_attributes);
+    return attr;
+}
+
+static int ctr_span_set_attributes(struct ctrace_span *span,
+                                   size_t n_attributes,
+                                   Opentelemetry__Proto__Common__V1__KeyValue **attributes)
+{
+    struct ctrace_attributes *ctr_attributes;
+
+    ctr_attributes = convert_otel_attrs(n_attributes, attributes);
+    if (ctr_attributes == NULL) {
+        return -1;
+    }
+
+    if (span->attr) {
+        ctr_attributes_destroy(span->attr);
+    }
+    span->attr = ctr_attributes;
+    return 0;
+}
+
+static int ctr_span_set_events(struct ctrace_span *span,
+                               size_t n_events,
+                               Opentelemetry__Proto__Trace__V1__Span__Event **events)
+{
+    int index_event;
+    struct ctrace_span_event *ctr_event;
+    struct ctrace_attributes *ctr_attributes;
+    Opentelemetry__Proto__Trace__V1__Span__Event *event;
+
+    cfl_list_init(&span->events);
+
+    for (index_event = 0; index_event < n_events; index_event++) {
+        event = events[index_event];
+
+        ctr_event = ctr_span_event_add_ts(span, event->name, event->time_unix_nano);
+
+        if (ctr_event == NULL) {
+            return -1;
+        }
+
+        ctr_attributes = convert_otel_attrs(event->n_attributes, event->attributes);
+
+        if (ctr_attributes == NULL) {
+            return -1;
+        }
+
+        if (ctr_event->attr) {
+            ctr_attributes_destroy(ctr_event->attr);
+        }
+
+        ctr_event->attr = ctr_attributes;
+        ctr_span_event_set_dropped_attributes_count(ctr_event, event->dropped_attributes_count);
+    }
+
+    return 0;
+}
+
+static int resource_set_data(struct ctrace_resource *resource,
+                             Opentelemetry__Proto__Resource__V1__Resource *otel_resource)
+{
+    struct ctrace_attributes *attributes;
+
+    attributes = convert_otel_attrs(otel_resource->n_attributes, otel_resource->attributes);
+
+    if (attributes == NULL) {
+        return -1;
+    }
+
+    ctr_resource_set_attributes(resource, attributes);
+    ctr_resource_set_dropped_attr_count(resource, otel_resource->dropped_attributes_count);
+
+    return 0;
+}
+
+void ctr_scope_span_set_scope(struct ctrace_scope_span *scope_span,
+                              Opentelemetry__Proto__Common__V1__InstrumentationScope *scope)
+{
+    struct ctrace_attributes *ctr_attributes;
+    struct ctrace_instrumentation_scope *ins_scope;
+
+    ctr_attributes = convert_otel_attrs(scope->n_attributes, scope->attributes);
+    if (ctr_attributes == NULL) {
+        return;
+    }
+
+    ins_scope = ctr_instrumentation_scope_create(scope->name, scope->version,
+                                                 scope->dropped_attributes_count,
+                                                 ctr_attributes);
+    if (!ins_scope) {
+        ctr_attributes_destroy(ctr_attributes);
+        return;
+    }
+
+    ctr_scope_span_set_instrumentation_scope(scope_span, ins_scope);
+}
+
+void ctr_span_set_links(struct ctrace_span *ctr_span, size_t n_links,
+     Opentelemetry__Proto__Trace__V1__Span__Link **links)
+{
+    int index_link;
+    struct ctrace_link *ctr_link;
+    struct ctrace_attributes *ctr_attributes;
+    Opentelemetry__Proto__Trace__V1__Span__Link *link;
+
+    for (index_link = 0; index_link < n_links; index_link++) {
+        link = links[index_link];
+
+        ctr_link = ctr_link_create(ctr_span,
+                                   link->trace_id.data, link->trace_id.len,
+                                   link->span_id.data, link->span_id.len);
+
+        if (ctr_link == NULL) {
+            return;
+        }
+
+        ctr_attributes = convert_otel_attrs(link->n_attributes, link->attributes);
+
+        if (ctr_attributes == NULL) {
+            return;
+        }
+
+        ctr_link->attr = ctr_attributes;
+        ctr_link_set_dropped_attr_count(ctr_link, link->dropped_attributes_count);
+    }
+
+}
+
+int ctr_decode_opentelemetry_create(struct ctrace **out_ctr,
+                                    char *in_buf,
+                                    size_t in_size, size_t *offset)
+{
+    size_t resource_span_index;
+    size_t scope_span_index;
+    size_t span_index;
+    struct ctrace *ctr;
+    struct ctrace_span *span;
+    struct ctrace_resource *resource;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_scope_span *scope_span;
+
+    Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *service_request;
+    Opentelemetry__Proto__Trace__V1__ResourceSpans *otel_resource_span;
+    Opentelemetry__Proto__Trace__V1__ScopeSpans *otel_scope_span;
+    Opentelemetry__Proto__Trace__V1__Span *otel_span;
+
+    service_request = opentelemetry__proto__collector__trace__v1__export_trace_service_request__unpack(NULL,
+                                                                                                      in_size - *offset,
+                                                                                                      (unsigned char *) &in_buf[*offset]);
+    if (service_request == NULL) {
+        return -1;
+    }
+
+    ctr = ctr_create(NULL);
+
+    for (resource_span_index = 0; resource_span_index < service_request->n_resource_spans; resource_span_index++) {
+        otel_resource_span = service_request->resource_spans[resource_span_index];
+        if (otel_resource_span == NULL) {
+            opentelemetry__proto__collector__trace__v1__export_trace_service_request__free_unpacked(service_request, NULL);
+            return -1;
+        }
+
+        /* resource span */
+        resource_span = ctr_resource_span_create(ctr);
+        ctr_resource_span_set_schema_url(resource_span, otel_resource_span->schema_url);
+
+        /* resource */
+        resource = ctr_resource_span_get_resource(resource_span);
+        resource_set_data(resource, otel_resource_span->resource);
+
+        for (scope_span_index = 0; scope_span_index < otel_resource_span->n_scope_spans; scope_span_index++) {
+            otel_scope_span = otel_resource_span->scope_spans[scope_span_index];
+            if (otel_scope_span == NULL) {
+                opentelemetry__proto__collector__trace__v1__export_trace_service_request__free_unpacked(service_request, NULL);
+                return -1;
+            }
+
+            scope_span = ctr_scope_span_create(resource_span);
+            ctr_scope_span_set_schema_url(scope_span, otel_scope_span->schema_url);
+            ctr_scope_span_set_scope(scope_span, otel_scope_span->scope);
+
+            for (span_index = 0; span_index < otel_scope_span->n_spans; span_index++) {
+                otel_span = otel_scope_span->spans[span_index];
+                if (otel_span == NULL) {
+                    opentelemetry__proto__collector__trace__v1__export_trace_service_request__free_unpacked(service_request, NULL);
+                    return -1;
+                }
+
+                span = ctr_span_create(ctr, scope_span, otel_span->name, NULL);
+
+                /* copy data from otel span to ctraces span representation */
+                ctr_span_set_trace_id(span, otel_span->trace_id.data, otel_span->trace_id.len);
+                ctr_span_set_span_id(span, otel_span->span_id.data, otel_span->span_id.len);
+                ctr_span_set_parent_span_id(span, otel_span->parent_span_id.data, otel_span->parent_span_id.len);
+                ctr_span_kind_set(span, otel_span->kind);
+                ctr_span_start_ts(ctr, span, otel_span->start_time_unix_nano);
+                ctr_span_end_ts(ctr, span, otel_span->end_time_unix_nano);
+                ctr_span_set_status(span, otel_span->status->code, otel_span->status->message);
+                ctr_span_set_attributes(span, otel_span->n_attributes, otel_span->attributes);
+                ctr_span_set_events(span, otel_span->n_events, otel_span->events);
+                ctr_span_set_dropped_attributes_count(span, otel_span->dropped_attributes_count);
+                ctr_span_set_dropped_events_count(span, otel_span->dropped_events_count);
+                ctr_span_set_links(span, otel_span->n_links, otel_span->links);
+            }
+        }
+    }
+
+    opentelemetry__proto__collector__trace__v1__export_trace_service_request__free_unpacked(service_request, NULL);
+    *out_ctr = ctr;
+
+    return 0;
+}
+
+void ctr_decode_opentelemetry_destroy(struct ctrace *ctr)
+{
+    ctr_destroy(ctr);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_encode_msgpack.c b/fluent-bit/lib/ctraces/src/ctr_encode_msgpack.c
new file mode 100644
index 000000000..bd3d187bf
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_encode_msgpack.c
@@ -0,0 +1,528 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+/* local declarations */
+static void pack_variant(mpack_writer_t *writer, struct cfl_variant *variant);
+
+static void pack_bool(mpack_writer_t *writer, int b)
+{
+    if (b) {
+        mpack_write_true(writer);
+    }
+    else {
+        mpack_write_false(writer);
+    }
+}
+
+static void pack_string(mpack_writer_t *writer, cfl_sds_t str)
+{
+    mpack_write_str(writer, str, cfl_sds_len(str));
+}
+
+static void pack_int64(mpack_writer_t *writer, int64_t val)
+{
+    mpack_write_i64(writer, val);
+}
+
+static void pack_double(mpack_writer_t *writer, double val)
+{
+    mpack_write_double(writer, val);
+}
+
+static void pack_array(mpack_writer_t *writer, struct cfl_array *array)
+{
+    int i;
+    struct cfl_variant *entry;
+
+    mpack_start_array(writer, array->entry_count);
+
+    for (i = 0; i < array->entry_count; i++) {
+        entry = array->entries[i];
+        pack_variant(writer, entry);
+    }
+    mpack_finish_array(writer);
+}
+
+static void pack_kvlist(mpack_writer_t *writer, struct cfl_kvlist *kvlist)
+{
+    int count;
+    struct cfl_list *head;
+    struct cfl_list *list;
+    struct cfl_kvpair *kvpair;
+
+    list = &kvlist->list;
+    count = cfl_list_size(list);
+
+    mpack_start_map(writer, count);
+
+    cfl_list_foreach(head, list) {
+        kvpair = cfl_list_entry(head, struct cfl_kvpair, _head);
+
+        /* key */
+        mpack_write_str(writer, kvpair->key, cfl_sds_len(kvpair->key));
+
+        /* value */
+        pack_variant(writer, kvpair->val);
+    }
+    mpack_finish_map(writer);
+}
+
+static void pack_bytes(mpack_writer_t *writer, cfl_sds_t bytes)
+{
+    size_t len;
+
+    len = cfl_sds_len(bytes);
+
+    // mpack_start_bin(writer, len);
+    mpack_write_bin(writer, bytes, len);
+    // mpack_finish_bin(writer);
+}
+
+static void pack_variant(mpack_writer_t *writer, struct cfl_variant *variant)
+{
+    int type = variant->type;
+
+    if (type == CFL_VARIANT_STRING) {
+        pack_string(writer, variant->data.as_string);
+    }
+    else if (type == CFL_VARIANT_BOOL) {
+        pack_bool(writer, variant->data.as_bool);
+    }
+    else if (type == CFL_VARIANT_INT) {
+        pack_int64(writer, variant->data.as_int64);
+    }
+    else if (type == CFL_VARIANT_DOUBLE) {
+        pack_double(writer, variant->data.as_double);
+    }
+    else if (type == CFL_VARIANT_ARRAY) {
+        pack_array(writer, variant->data.as_array);
+    }
+    else if (type == CFL_VARIANT_KVLIST) {
+        pack_kvlist(writer, variant->data.as_kvlist);
+    }
+    else if (type == CFL_VARIANT_BYTES) {
+        pack_bytes(writer, variant->data.as_bytes);
+    }
+    else if (type == CFL_VARIANT_REFERENCE) {
+        /* unsupported */
+    }
+}
+
+static void pack_attributes(mpack_writer_t *writer, struct ctrace_attributes *attr)
+{
+    struct cfl_kvlist *kvlist;
+
+    kvlist = attr->kv;
+    pack_kvlist(writer, kvlist);
+}
+
+static void pack_instrumentation_scope(mpack_writer_t *writer, struct ctrace_instrumentation_scope *ins_scope)
+{
+    mpack_start_map(writer, 4);
+
+    /* name */
+    mpack_write_cstr(writer, "name");
+    if (ins_scope->name) {
+        mpack_write_str(writer, ins_scope->name, cfl_sds_len(ins_scope->name));
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* version */
+    mpack_write_cstr(writer, "version");
+    if (ins_scope->version) {
+        mpack_write_str(writer, ins_scope->version, cfl_sds_len(ins_scope->version));
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* attributes */
+    mpack_write_cstr(writer, "attributes");
+    if (ins_scope->attr) {
+        pack_attributes(writer, ins_scope->attr);
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* dropped_attributes_count */
+    mpack_write_cstr(writer, "dropped_attributes_count");
+    mpack_write_u32(writer, ins_scope->dropped_attr_count);
+
+    /* finish */
+    mpack_finish_map(writer);
+}
+
+static void pack_id(mpack_writer_t *writer, struct ctrace_id *id)
+{
+    cfl_sds_t encoded_id;
+
+
+    if (id) {
+        encoded_id = ctr_id_to_lower_base16(id);
+
+        if (encoded_id != NULL) {
+            mpack_write_cstr(writer, encoded_id);
+
+            cfl_sds_destroy(encoded_id);
+        }
+        else {
+            /* we should be able to report this but at the moment
+             * we are not.
+             */
+
+            mpack_write_nil(writer);
+        }
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+}
+
+static void pack_events(mpack_writer_t *writer, struct cfl_list *events)
+{
+    int count;
+    struct cfl_list *head;
+    struct ctrace_span_event *event;
+
+    count = cfl_list_size(events);
+    mpack_start_array(writer, count);
+
+    cfl_list_foreach(head, events) {
+        event = cfl_list_entry(head, struct ctrace_span_event, _head);
+
+        /* start event map */
+        mpack_start_map(writer, 4);
+
+        /* time_unix_nano */
+        mpack_write_cstr(writer, "time_unix_nano");
+        mpack_write_u64(writer, event->time_unix_nano);
+
+        /* name */
+        mpack_write_cstr(writer, "name");
+        if (event->name) {
+            mpack_write_str(writer, event->name, cfl_sds_len(event->name));
+        }
+        else {
+            mpack_write_nil(writer);
+        }
+
+        /* attributes */
+        mpack_write_cstr(writer, "attributes");
+        if (event->attr) {
+            pack_attributes(writer, event->attr);
+        }
+        else {
+            mpack_write_nil(writer);
+        }
+
+        /* dropped_attributes_count */
+        mpack_write_cstr(writer, "dropped_attributes_count");
+        mpack_write_u32(writer, event->dropped_attr_count);
+
+        /* finish event map */
+        mpack_finish_map(writer);
+    }
+
+    mpack_finish_array(writer);
+}
+
+static void pack_links(mpack_writer_t *writer, struct cfl_list *links)
+{
+    int count;
+    struct cfl_list *head;
+    struct ctrace_link *link;
+
+    count = cfl_list_size(links);
+    mpack_start_array(writer, count);
+
+    cfl_list_foreach(head, links) {
+        link = cfl_list_entry(head, struct ctrace_link, _head);
+
+        /* start map */
+        mpack_start_map(writer, 5);
+
+        /* trace_id */
+        mpack_write_cstr(writer, "trace_id");
+        pack_id(writer, link->trace_id);
+
+        /* span_id */
+        mpack_write_cstr(writer, "span_id");
+        pack_id(writer, link->span_id);
+
+        /* trace_state */
+        mpack_write_cstr(writer, "trace_state");
+        if (link->trace_state) {
+            mpack_write_str(writer, link->trace_state, cfl_sds_len(link->trace_state));
+        }
+        else {
+            mpack_write_nil(writer);
+        }
+
+        /* attributes */
+        mpack_write_cstr(writer, "attributes");
+        if (link->attr) {
+            pack_attributes(writer, link->attr);
+        }
+        else {
+            mpack_write_nil(writer);
+        }
+
+        /* dropped_attributes_count */
+        mpack_write_cstr(writer, "dropped_attributes_count");
+        mpack_write_u32(writer, link->dropped_attr_count);
+
+        /* end map */
+        mpack_finish_map(writer);
+    }
+
+    mpack_finish_array(writer);
+}
+
+static void pack_span(mpack_writer_t *writer, struct ctrace_span *span)
+{
+    mpack_start_map(writer, 13);
+
+    /* trace_id */
+    mpack_write_cstr(writer, "trace_id");
+    pack_id(writer, span->trace_id);
+
+    /* span_id */
+    mpack_write_cstr(writer, "span_id");
+    pack_id(writer, span->span_id);
+
+    /* parent_span_id */
+    mpack_write_cstr(writer, "parent_span_id");
+    pack_id(writer, span->parent_span_id);
+
+    /* trace_state */
+    mpack_write_cstr(writer, "trace_state");
+    if (span->trace_state) {
+        mpack_write_str(writer, span->trace_state, cfl_sds_len(span->trace_state));
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* name */
+    mpack_write_cstr(writer, "name");
+    if (span->name) {
+        mpack_write_str(writer, span->name, cfl_sds_len(span->name));
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* kind */
+    mpack_write_cstr(writer, "kind");
+    mpack_write_u32(writer, span->kind);
+
+    /* start_time_unix_nano */
+    mpack_write_cstr(writer, "start_time_unix_nano");
+    mpack_write_u64(writer, span->start_time_unix_nano);
+
+    /* end_time_unix_nano */
+    mpack_write_cstr(writer, "end_time_unix_nano");
+    mpack_write_u64(writer, span->end_time_unix_nano);
+
+    /* attributes */
+    mpack_write_cstr(writer, "attributes");
+    if (span->attr) {
+        pack_attributes(writer, span->attr);
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+
+    /* dropped_attributes_count */
+    mpack_write_cstr(writer, "dropped_attributes_count");
+    mpack_write_u32(writer, span->dropped_attr_count);
+
+    /* events */
+    mpack_write_cstr(writer, "events");
+    pack_events(writer, &span->events);
+
+    /* links */
+    mpack_write_cstr(writer, "links");
+    pack_links(writer, &span->links);
+
+    /* span_status */
+    mpack_write_cstr(writer, "status");
+    mpack_start_map(writer, 2);
+    mpack_write_cstr(writer, "code");
+    mpack_write_i32(writer, span->status.code);
+    mpack_write_cstr(writer, "message");
+    if (span->status.message) {
+        mpack_write_str(writer, span->status.message, cfl_sds_len(span->status.message));
+    }
+    else {
+        mpack_write_nil(writer);
+    }
+    mpack_finish_map(writer);
+
+    mpack_finish_map(writer);
+}
+
+static void pack_spans(mpack_writer_t *writer, struct cfl_list *spans)
+{
+    int count;
+    struct cfl_list *head;
+    struct ctrace_span *span;
+
+    count = cfl_list_size(spans);
+    mpack_start_array(writer, count);
+
+     cfl_list_foreach(head, spans) {
+        span = cfl_list_entry(head, struct ctrace_span, _head);
+        pack_span(writer, span);
+    }
+
+    mpack_finish_array(writer);
+}
+
+static void pack_scope_spans(mpack_writer_t *writer, struct cfl_list *scope_spans)
+{
+    int count;
+    struct cfl_list *head;
+    struct ctrace_scope_span *scope_span;
+
+    count = cfl_list_size(scope_spans);
+
+    mpack_write_cstr(writer, "scope_spans");
+    mpack_start_array(writer, count);
+
+    cfl_list_foreach(head, scope_spans) {
+        scope_span = cfl_list_entry(head, struct ctrace_scope_span, _head);
+
+        mpack_start_map(writer, 3);
+
+        /* scope */
+        mpack_write_cstr(writer, "scope");
+        pack_instrumentation_scope(writer, scope_span->instrumentation_scope);
+
+        /* spans */
+        mpack_write_cstr(writer, "spans");
+        pack_spans(writer, &scope_span->spans);
+
+        /* schema_url */
+        mpack_write_cstr(writer, "schema_url");
+        if (scope_span->schema_url) {
+            mpack_write_str(writer, scope_span->schema_url, cfl_sds_len(scope_span->schema_url));
+        }
+        else {
+            mpack_write_nil(writer);
+        }
+
+        mpack_finish_map(writer);
+    }
+
+    mpack_finish_array(writer);
+}
+
+int ctr_encode_msgpack_create(struct ctrace *ctx,  char **out_buf, size_t *out_size)
+{
+    int count;
+    char *data;
+    size_t size;
+    mpack_writer_t writer;
+    struct cfl_list *head;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_resource *resource;
+
+    if (ctx == NULL) {
+        return -1;
+    }
+
+    mpack_writer_init_growable(&writer, &data, &size);
+
+    /* root map */
+    mpack_start_map(&writer, 1);
+
+    /* resourceSpan */
+    mpack_write_cstr(&writer, "resourceSpans");
+
+    /* array */
+    count = cfl_list_size(&ctx->resource_spans);
+    mpack_start_array(&writer, count);
+
+    cfl_list_foreach(head, &ctx->resource_spans) {
+        resource_span = cfl_list_entry(head, struct ctrace_resource_span, _head);
+
+        /* resourceSpans is an array of maps, each maps containers a 'resource', 'schema_url' and 'scopeSpans' entry */
+        mpack_start_map(&writer, 3);
+
+        /* resource key */
+        resource = resource_span->resource;
+        mpack_write_cstr(&writer, "resource");
+
+        /* resource val */
+        mpack_start_map(&writer, 2);
+
+        /* resource[0]: attributes */
+        mpack_write_cstr(&writer, "attributes");
+        if (resource->attr) {
+            pack_attributes(&writer, resource->attr);
+        }
+        else {
+            mpack_write_nil(&writer);
+        }
+
+        /* resource[1]: dropped_attributes_count */
+        mpack_write_cstr(&writer, "dropped_attributes_count");
+        mpack_write_u32(&writer, resource->dropped_attr_count);
+
+        mpack_finish_map(&writer);
+
+        /* schema_url */
+        mpack_write_cstr(&writer, "schema_url");
+        if (resource_span->schema_url) {
+            mpack_write_str(&writer, resource_span->schema_url, cfl_sds_len(resource_span->schema_url));
+        }
+        else {
+            mpack_write_nil(&writer);
+        }
+
+        /* scopeSpans */
+        pack_scope_spans(&writer, &resource_span->scope_spans);
+
+        mpack_finish_map(&writer); /* !resourceSpans map value */
+    }
+
+    mpack_finish_array(&writer);
+    mpack_finish_map(&writer);
+
+    if (mpack_writer_destroy(&writer) != mpack_ok) {
+        fprintf(stderr, "An error occurred encoding the data!\n");
+        return -1;
+    }
+
+    *out_buf = data;
+    *out_size = size;
+
+    return 0;
+}
+
+void ctr_encode_msgpack_destroy(char *buf)
+{
+    free(buf);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_encode_opentelemetry.c b/fluent-bit/lib/ctraces/src/ctr_encode_opentelemetry.c
new file mode 100644
index 000000000..e8a95f149
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_encode_opentelemetry.c
@@ -0,0 +1,1322 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include <fluent-otel-proto/fluent-otel.h>
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_to_otlp_any_value(struct cfl_variant *value);
+static inline Opentelemetry__Proto__Common__V1__KeyValue *ctr_variant_kvpair_to_otlp_kvpair(struct cfl_kvpair *input_pair);
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_kvlist_to_otlp_any_value(struct cfl_variant *value);
+
+static inline void otlp_any_value_destroy(Opentelemetry__Proto__Common__V1__AnyValue *value);
+static inline void otlp_kvpair_destroy(Opentelemetry__Proto__Common__V1__KeyValue *kvpair);
+static inline void otlp_kvlist_destroy(Opentelemetry__Proto__Common__V1__KeyValueList *kvlist);
+static inline void otlp_array_destroy(Opentelemetry__Proto__Common__V1__ArrayValue *array);
+
+static inline void otlp_kvpair_list_destroy(Opentelemetry__Proto__Common__V1__KeyValue **pair_list, size_t entry_count);
+
+static inline void otlp_kvpair_destroy(Opentelemetry__Proto__Common__V1__KeyValue *kvpair)
+{
+    if (kvpair != NULL) {
+        if (kvpair->key != NULL) {
+            free(kvpair->key);
+        }
+
+        if (kvpair->value != NULL) {
+            otlp_any_value_destroy(kvpair->value);
+        }
+
+        free(kvpair);
+    }
+}
+
+static inline void otlp_kvlist_destroy(Opentelemetry__Proto__Common__V1__KeyValueList *kvlist)
+{
+    size_t index;
+
+    if (kvlist != NULL) {
+        if (kvlist->values != NULL) {
+            for (index = 0 ; index < kvlist->n_values ; index++) {
+                otlp_kvpair_destroy(kvlist->values[index]);
+            }
+
+            free(kvlist->values);
+        }
+
+        free(kvlist);
+    }
+}
+
+static inline void otlp_array_destroy(Opentelemetry__Proto__Common__V1__ArrayValue *array)
+{
+    size_t index;
+
+    if (array != NULL) {
+        if (array->values != NULL) {
+            for (index = 0 ; index < array->n_values ; index++) {
+                otlp_any_value_destroy(array->values[index]);
+            }
+
+            free(array->values);
+        }
+
+        free(array);
+    }
+}
+
+static inline void otlp_any_value_destroy(Opentelemetry__Proto__Common__V1__AnyValue *value)
+{
+    if (value != NULL) {
+        if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE) {
+            if (value->string_value != NULL) {
+                free(value->string_value);
+                value->string_value = NULL;
+            }
+        }
+        else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_ARRAY_VALUE) {
+            if (value->array_value != NULL) {
+                otlp_array_destroy(value->array_value);
+            }
+        }
+        else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_KVLIST_VALUE) {
+            if (value->kvlist_value != NULL) {
+                otlp_kvlist_destroy(value->kvlist_value);
+            }
+        }
+        else if (value->value_case == OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BYTES_VALUE) {
+            if (value->bytes_value.data != NULL) {
+                free(value->bytes_value.data);
+            }
+        }
+
+        free(value);
+        value = NULL;
+    }
+}
+
+static inline Opentelemetry__Proto__Common__V1__KeyValue **otlp_kvpair_list_initialize(size_t entry_count)
+{
+    Opentelemetry__Proto__Common__V1__KeyValue **result;
+
+    result = \
+        calloc(entry_count, sizeof(Opentelemetry__Proto__Common__V1__KeyValue *));
+
+    if (result == NULL) {
+        ctr_errno();
+        return NULL;
+    }
+
+    return result;
+}
+
+
+static Opentelemetry__Proto__Common__V1__ArrayValue *otlp_array_value_initialize(size_t entry_count)
+{
+    Opentelemetry__Proto__Common__V1__ArrayValue *value;
+
+    value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__ArrayValue));
+
+    if (value != NULL) {
+        opentelemetry__proto__common__v1__array_value__init(value);
+
+        if (entry_count > 0) {
+            value->values = \
+                calloc(entry_count,
+                       sizeof(Opentelemetry__Proto__Common__V1__AnyValue *));
+
+            if (value->values == NULL) {
+                free(value);
+
+                value = NULL;
+            }
+            else {
+                value->n_values = entry_count;
+            }
+        }
+    }
+
+    return value;
+}
+
+static Opentelemetry__Proto__Common__V1__KeyValue *otlp_kvpair_value_initialize()
+{
+    Opentelemetry__Proto__Common__V1__KeyValue *value;
+
+    value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__KeyValue));
+
+    if (value != NULL) {
+        opentelemetry__proto__common__v1__key_value__init(value);
+    }
+
+    return value;
+}
+
+static Opentelemetry__Proto__Common__V1__KeyValueList *otlp_kvlist_value_initialize(size_t entry_count)
+{
+    Opentelemetry__Proto__Common__V1__KeyValueList *value;
+
+    value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__KeyValueList));
+
+    if (value != NULL) {
+        opentelemetry__proto__common__v1__key_value_list__init(value);
+
+        if (entry_count > 0) {
+            value->values = \
+                calloc(entry_count,
+                       sizeof(Opentelemetry__Proto__Common__V1__KeyValue *));
+
+            if (value->values == NULL) {
+                free(value);
+
+                value = NULL;
+            }
+            else {
+                value->n_values = entry_count;
+            }
+        }
+    }
+
+    return value;
+}
+
+static Opentelemetry__Proto__Common__V1__AnyValue *otlp_any_value_initialize(int data_type, size_t entry_count)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *value;
+
+    value = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__AnyValue));
+
+    if (value == NULL) {
+        return NULL;
+    }
+
+    opentelemetry__proto__common__v1__any_value__init(value);
+
+    if (data_type == CFL_VARIANT_STRING) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE;
+    }
+    else if (data_type == CFL_VARIANT_BOOL) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BOOL_VALUE;
+    }
+    else if (data_type == CFL_VARIANT_INT) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_INT_VALUE;
+    }
+    else if (data_type == CFL_VARIANT_DOUBLE) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_DOUBLE_VALUE;
+    }
+    else if (data_type == CFL_VARIANT_ARRAY) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_ARRAY_VALUE;
+
+        value->array_value = otlp_array_value_initialize(entry_count);
+
+        if (value->array_value == NULL) {
+            free(value);
+
+            value = NULL;
+        }
+    }
+    else if (data_type == CFL_VARIANT_KVLIST) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_KVLIST_VALUE;
+
+        value->kvlist_value = otlp_kvlist_value_initialize(entry_count);
+
+        if (value->kvlist_value == NULL) {
+            free(value);
+
+            value = NULL;
+        }
+    }
+    else if (data_type == CFL_VARIANT_BYTES) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_BYTES_VALUE;
+    }
+    else if (data_type == CFL_VARIANT_REFERENCE) {
+        value->value_case = OPENTELEMETRY__PROTO__COMMON__V1__ANY_VALUE__VALUE_STRING_VALUE;
+    }
+    else {
+        free(value);
+
+        value = NULL;
+    }
+
+    return value;
+}
+
+static inline Opentelemetry__Proto__Common__V1__KeyValue *ctr_variant_kvpair_to_otlp_kvpair(struct cfl_kvpair *input_pair)
+{
+    Opentelemetry__Proto__Common__V1__KeyValue *kv;
+
+    kv = otlp_kvpair_value_initialize();
+    if (kv == NULL) {
+        ctr_errno();
+        return NULL;
+    }
+
+    kv->key = strdup(input_pair->key);
+    if (kv->key == NULL) {
+        ctr_errno();
+        free(kv);
+        return NULL;
+    }
+
+    kv->value = ctr_variant_to_otlp_any_value(input_pair->val);
+    if (kv->value == NULL) {
+        ctr_errno();
+        free(kv->key);
+        free(kv);
+        return NULL;
+    }
+
+    return kv;
+}
+
+static inline void otlp_kvpair_list_destroy(Opentelemetry__Proto__Common__V1__KeyValue **pair_list, size_t entry_count)
+{
+    size_t index;
+
+    if (pair_list != NULL) {
+        for (index = 0 ; index < entry_count ; index++) {
+            otlp_kvpair_destroy(pair_list[index]);
+        }
+
+        free(pair_list);
+        pair_list = NULL;
+    }
+}
+
+static inline Opentelemetry__Proto__Common__V1__KeyValue **ctr_kvlist_to_otlp_kvpair_list(struct cfl_kvlist *kvlist)
+{
+    size_t                                       entry_count;
+    Opentelemetry__Proto__Common__V1__KeyValue  *keyvalue;
+    struct cfl_list                             *iterator;
+    Opentelemetry__Proto__Common__V1__KeyValue **result;
+    struct cfl_kvpair                           *kvpair;
+    size_t                                       index;
+
+    entry_count = cfl_kvlist_count(kvlist);
+
+    result = otlp_kvpair_list_initialize(entry_count);
+
+    if (result != NULL) {
+        index = 0;
+
+        cfl_list_foreach(iterator, &kvlist->list) {
+            kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head);
+
+            keyvalue = ctr_variant_kvpair_to_otlp_kvpair(kvpair);
+
+            if (keyvalue == NULL) {
+                otlp_kvpair_list_destroy(result, entry_count);
+
+                result = NULL;
+
+                break;
+            }
+
+            result[index++] = keyvalue;
+        }
+    }
+
+    return result;
+}
+
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_kvlist_to_otlp_any_value(struct cfl_variant *value)
+{
+    size_t                                      entry_count;
+    Opentelemetry__Proto__Common__V1__KeyValue *keyvalue;
+    struct cfl_list                            *iterator;
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+    struct cfl_kvpair                          *kvpair;
+    struct cfl_kvlist                          *kvlist;
+    size_t                                      index;
+
+
+    kvlist = value->data.as_kvlist;
+
+    entry_count = cfl_kvlist_count(kvlist);
+
+    result = otlp_any_value_initialize(CFL_VARIANT_KVLIST, entry_count);
+
+    if (result != NULL) {
+        index = 0;
+
+        cfl_list_foreach(iterator, &kvlist->list) {
+            kvpair = cfl_list_entry(iterator, struct cfl_kvpair, _head);
+
+            keyvalue = ctr_variant_kvpair_to_otlp_kvpair(kvpair);
+
+            if (keyvalue == NULL) {
+                otlp_any_value_destroy(result);
+
+                result = NULL;
+
+                break;
+            }
+
+            result->kvlist_value->values[index++] = keyvalue;
+        }
+    }
+
+    return result;
+}
+
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_array_to_otlp_any_value(struct cfl_variant *value)
+{
+    size_t                                      entry_count;
+    Opentelemetry__Proto__Common__V1__AnyValue *entry_value;
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+    struct cfl_array                           *array;
+    size_t                                      index;
+
+    array = value->data.as_array;
+
+    entry_count = array->entry_count;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_ARRAY, entry_count);
+
+    if (result != NULL) {
+        index = 0;
+
+        for (index = 0 ; index < entry_count ; index++) {
+            entry_value = ctr_variant_to_otlp_any_value(cfl_array_fetch_by_index(array, index));
+
+            if (entry_value == NULL) {
+                otlp_any_value_destroy(result);
+
+                result = NULL;
+
+                break;
+            }
+
+            result->array_value->values[index] = entry_value;
+        }
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_string_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_STRING, 0);
+
+    if (result != NULL) {
+        result->string_value = strdup(value->data.as_string);
+
+        if (result->string_value == NULL) {
+            otlp_any_value_destroy(result);
+
+            result = NULL;
+        }
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_boolean_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_BOOL, 0);
+
+    if (result != NULL) {
+        result->bool_value = value->data.as_bool;
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_int64_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_INT, 0);
+
+    if (result != NULL) {
+        result->int_value = value->data.as_int64;
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_double_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_DOUBLE, 0);
+
+    if (result != NULL) {
+        result->double_value = value->data.as_double;
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_binary_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    result = otlp_any_value_initialize(CFL_VARIANT_BYTES, 0);
+
+    if (result != NULL) {
+        result->bytes_value.len = cfl_sds_len(value->data.as_bytes);
+        result->bytes_value.data = calloc(result->bytes_value.len, sizeof(char));
+
+        if (result->bytes_value.data == NULL) {
+            otlp_any_value_destroy(result);
+
+            result = NULL;
+        }
+
+        memcpy(result->bytes_value.data, value->data.as_bytes, result->bytes_value.len);
+    }
+
+    return result;
+}
+
+static inline Opentelemetry__Proto__Common__V1__AnyValue *ctr_variant_to_otlp_any_value(struct cfl_variant *value)
+{
+    Opentelemetry__Proto__Common__V1__AnyValue *result;
+
+    if (value->type == CFL_VARIANT_STRING) {
+        result = ctr_variant_string_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_BOOL) {
+        result = ctr_variant_boolean_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_INT) {
+        result = ctr_variant_int64_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_DOUBLE) {
+        result = ctr_variant_double_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_ARRAY) {
+        result = ctr_variant_array_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_KVLIST) {
+        result = ctr_variant_kvlist_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_BYTES) {
+        result = ctr_variant_binary_to_otlp_any_value(value);
+    }
+    else if (value->type == CFL_VARIANT_REFERENCE) {
+        result = ctr_variant_string_to_otlp_any_value(value);
+    }
+    else {
+        result = NULL;
+    }
+
+    return result;
+}
+
+static Opentelemetry__Proto__Common__V1__KeyValue **set_attributes_from_ctr(struct ctrace_attributes *attr)
+{
+    if(attr == NULL) {
+        return NULL;
+    }
+
+    return ctr_kvlist_to_otlp_kvpair_list(attr->kv);
+}
+
+static Opentelemetry__Proto__Resource__V1__Resource *initialize_resource()
+{
+    Opentelemetry__Proto__Resource__V1__Resource *resource;
+
+    resource = calloc(1, sizeof(Opentelemetry__Proto__Resource__V1__Resource));
+
+    if (!resource) {
+        ctr_errno();
+        return NULL;
+    }
+
+    opentelemetry__proto__resource__v1__resource__init(resource);
+
+    return resource;
+}
+
+static size_t get_attributes_count(struct ctrace_attributes *attr)
+{
+    if (attr == NULL) {
+        return 0;
+    }
+
+    return cfl_kvlist_count(attr->kv);
+}
+
+static Opentelemetry__Proto__Resource__V1__Resource *ctr_set_resource(struct ctrace_resource *resource)
+{
+    Opentelemetry__Proto__Resource__V1__Resource *otel_resource;
+
+    otel_resource = initialize_resource();
+    if (!otel_resource) {
+        return NULL;
+    }
+
+    otel_resource->n_attributes = get_attributes_count(resource->attr);
+    otel_resource->attributes = set_attributes_from_ctr(resource->attr);
+    otel_resource->dropped_attributes_count = resource->dropped_attr_count;
+
+    return otel_resource;
+}
+
+static void otel_span_set_trace_id(Opentelemetry__Proto__Trace__V1__Span *span,
+                                   struct ctrace_id *trace_id)
+{
+    size_t len;
+    uint8_t *trace_id_str;
+
+    if (!trace_id) {
+        return;
+    }
+
+    len = ctr_id_get_len(trace_id);
+    trace_id_str = ctr_id_get_buf(trace_id);
+
+    span->trace_id.len = len;
+    span->trace_id.data = trace_id_str;
+}
+
+static void otel_span_set_span_id(Opentelemetry__Proto__Trace__V1__Span *span,
+                                  struct ctrace_id *span_id)
+{
+    size_t len;
+    uint8_t *span_id_str;
+
+    if (!span_id) {
+        return;
+    }
+
+    len = ctr_id_get_len(span_id);
+    span_id_str = ctr_id_get_buf(span_id);
+
+    span->span_id.len = len;
+    span->span_id.data = span_id_str;
+}
+
+static void otel_span_set_parent_span_id(Opentelemetry__Proto__Trace__V1__Span *span,
+                                         struct ctrace_id *parent)
+{
+    size_t len;
+    uint8_t *parent_id_str;
+
+    if (!parent) {
+        return;
+    }
+
+    len = ctr_id_get_len(parent);
+    parent_id_str = ctr_id_get_buf(parent);
+
+    span->parent_span_id.len = len;
+    span->parent_span_id.data = parent_id_str;
+}
+
+static void otel_span_set_kind(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                               int kind)
+{
+    switch (kind) {
+    case CTRACE_SPAN_INTERNAL:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_INTERNAL;
+        break;
+    case CTRACE_SPAN_SERVER:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_SERVER;
+        break;
+    case CTRACE_SPAN_CLIENT:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_CLIENT;
+        break;
+    case CTRACE_SPAN_PRODUCER:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_PRODUCER;
+        break;
+    case CTRACE_SPAN_CONSUMER:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_CONSUMER;
+        break;
+    default:
+        otel_span->kind = OPENTELEMETRY__PROTO__TRACE__V1__SPAN__SPAN_KIND__SPAN_KIND_UNSPECIFIED;
+        break;
+    }
+}
+
+static void otel_span_set_start_time(Opentelemetry__Proto__Trace__V1__Span *span,
+                                     uint64_t start_time)
+{
+    span->start_time_unix_nano = start_time;
+}
+
+static void otel_span_set_end_time(Opentelemetry__Proto__Trace__V1__Span *span,
+                                   uint64_t end_time)
+{
+    span->end_time_unix_nano = end_time;
+}
+
+static void otel_span_set_attributes(Opentelemetry__Proto__Trace__V1__Span *span,
+                                     struct ctrace_attributes *attr)
+{
+    span->n_attributes = get_attributes_count(attr);
+    span->attributes = set_attributes_from_ctr(attr);
+}
+
+static void otel_span_set_dropped_attributes_count(Opentelemetry__Proto__Trace__V1__Span *span,
+                                                   uint32_t dropped_attr_count)
+{
+    span->dropped_attributes_count = dropped_attr_count;
+}
+
+static Opentelemetry__Proto__Trace__V1__Span__Event *set_event(struct ctrace_span_event *ctr_event)
+{
+    Opentelemetry__Proto__Trace__V1__Span__Event *event;
+
+    event = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__Span__Event));
+    opentelemetry__proto__trace__v1__span__event__init(event);
+
+    event->time_unix_nano = ctr_event->time_unix_nano;
+    event->name = ctr_event->name;
+    event->n_attributes = ctr_attributes_count(ctr_event->attr);
+    event->attributes = set_attributes_from_ctr(ctr_event->attr);
+    event->dropped_attributes_count = ctr_event->dropped_attr_count;
+
+    return event;
+}
+
+static Opentelemetry__Proto__Trace__V1__Span__Event **set_events_from_ctr(struct cfl_list *events)
+{
+    int count;
+    int event_index;
+    struct cfl_list *head;
+    struct ctrace_span_event *ctr_event;
+
+    count = cfl_list_size(events);
+
+    Opentelemetry__Proto__Trace__V1__Span__Event **event_arr;
+
+    event_arr = calloc(count, sizeof(Opentelemetry__Proto__Trace__V1__Span__Event *));
+
+    event_index = 0;
+    cfl_list_foreach(head, events) {
+        ctr_event = cfl_list_entry(head, struct ctrace_span_event, _head);
+        event_arr[event_index++] = set_event(ctr_event);
+    }
+
+    return event_arr;
+}
+
+static void otel_span_set_events(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                                 struct cfl_list *events)
+{
+    otel_span->n_events = cfl_list_size(events);
+    otel_span->events = set_events_from_ctr(events);
+}
+
+static void otel_span_set_dropped_events_count(Opentelemetry__Proto__Trace__V1__Span *span,
+                                               uint32_t dropped_events_count)
+{
+    span->dropped_events_count = dropped_events_count;
+}
+
+static void otel_span_set_name(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                               char *name)
+{
+    otel_span->name = name;
+}
+
+static void otel_span_set_trace_state(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                                      char *trace_state)
+{
+    otel_span->trace_state = trace_state;
+}
+
+static void otel_span_set_status(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                                 struct ctrace_span_status status)
+{
+    Opentelemetry__Proto__Trace__V1__Status *otel_status;
+
+    otel_status = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__Status));
+    opentelemetry__proto__trace__v1__status__init(otel_status);
+
+    otel_status->code = status.code;
+    otel_status->message = status.message;
+
+    otel_span->status = otel_status;
+}
+
+static void otel_span_set_links(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                                struct cfl_list *links)
+{
+    int count;
+    int link_index;
+    struct cfl_list *head;
+    struct ctrace_link *link;
+    size_t link_span_id_size;
+    size_t link_trace_id_size;
+    uint8_t *link_trace_id;
+    uint8_t *link_span_id;
+
+    count = cfl_list_size(links);
+
+    Opentelemetry__Proto__Trace__V1__Span__Link **otel_links;
+    Opentelemetry__Proto__Trace__V1__Span__Link *otel_link;
+
+    otel_links = calloc(count, sizeof(Opentelemetry__Proto__Trace__V1__Span__Link *));
+
+    link_index = 0;
+
+    cfl_list_foreach(head, links) {
+        link = cfl_list_entry(head, struct ctrace_link, _head);
+
+        otel_link = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__Span__Link));
+        opentelemetry__proto__trace__v1__span__link__init(otel_link);
+
+        if (link->trace_id) {
+            link_trace_id_size = ctr_id_get_len(link->trace_id);
+            link_trace_id = ctr_id_get_buf(link->trace_id);
+
+            otel_link->trace_id.len = link_trace_id_size;
+            otel_link->trace_id.data = link_trace_id;
+        }
+
+        if (link->span_id) {
+            link_span_id_size = ctr_id_get_len(link->span_id);
+            link_span_id = ctr_id_get_buf(link->span_id);
+
+            otel_link->span_id.len = link_span_id_size;
+            otel_link->span_id.data = link_span_id;
+        }
+
+        otel_link->trace_state = link->trace_state;
+
+        otel_link->n_attributes = get_attributes_count(link->attr);
+        otel_link->attributes = set_attributes_from_ctr(link->attr);
+        otel_link->dropped_attributes_count = link->dropped_attr_count;
+
+        otel_links[link_index++] = otel_link;
+    }
+
+    otel_span->n_links = count;
+    otel_span->links = otel_links;
+}
+
+static void set_span(Opentelemetry__Proto__Trace__V1__Span *otel_span,
+                     struct ctrace_span *span)
+{
+    otel_span_set_name(otel_span, span->name);
+    otel_span_set_trace_id(otel_span, span->trace_id);
+    otel_span_set_span_id(otel_span, span->span_id);
+    otel_span_set_parent_span_id(otel_span, span->parent_span_id);
+    otel_span_set_kind(otel_span, span->kind);
+    otel_span_set_trace_state(otel_span, span->trace_state);
+    otel_span_set_start_time(otel_span, span->start_time_unix_nano);
+    otel_span_set_end_time(otel_span, span->end_time_unix_nano);
+    otel_span_set_status(otel_span, span->status);
+
+    otel_span_set_attributes(otel_span, span->attr);
+    otel_span_set_dropped_attributes_count(otel_span, span->dropped_attr_count);
+    otel_span_set_events(otel_span, &span->events);
+    otel_span_set_dropped_events_count(otel_span, span->dropped_events_count);
+    otel_span_set_links(otel_span, &span->links);
+}
+
+static Opentelemetry__Proto__Trace__V1__Span **initialize_spans(size_t span_count)
+{
+    Opentelemetry__Proto__Trace__V1__Span **spans;
+
+    spans = calloc(span_count, sizeof(Opentelemetry__Proto__Trace__V1__Span *));
+    if (!spans) {
+        ctr_errno();
+        return NULL;
+    }
+
+    return spans;
+}
+
+static Opentelemetry__Proto__Trace__V1__Span *initialize_span()
+{
+    Opentelemetry__Proto__Trace__V1__Span *span;
+
+    span = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__Span));
+    if (!span) {
+        ctr_errno();
+        return NULL;
+    }
+
+    opentelemetry__proto__trace__v1__span__init(span);
+
+    return span;
+}
+
+static Opentelemetry__Proto__Trace__V1__Span **set_spans(struct ctrace_scope_span *scope_span)
+{
+    int span_count;
+    int span_index;
+    struct cfl_list *head;
+    struct ctrace_span *span;
+
+    Opentelemetry__Proto__Trace__V1__Span **spans;
+    Opentelemetry__Proto__Trace__V1__Span *otel_span;
+
+    span_count = cfl_list_size(&scope_span->spans);
+    spans = initialize_spans(span_count);
+    if (!spans) {
+        return NULL;
+    }
+
+    span_index = 0;
+
+    cfl_list_foreach(head, &scope_span->spans) {
+        span = cfl_list_entry(head, struct ctrace_span, _head);
+
+        otel_span = initialize_span();
+        if (!otel_span) {
+            return NULL;
+        }
+
+        set_span(otel_span, span);
+        spans[span_index++] = otel_span;
+    }
+
+    return spans;
+}
+
+static Opentelemetry__Proto__Common__V1__InstrumentationScope *initialize_instrumentation_scope()
+{
+    Opentelemetry__Proto__Common__V1__InstrumentationScope *instrumentation_scope;
+
+    instrumentation_scope = calloc(1, sizeof(Opentelemetry__Proto__Common__V1__InstrumentationScope));
+    if (!instrumentation_scope) {
+        ctr_errno();
+        return NULL;
+    }
+    opentelemetry__proto__common__v1__instrumentation_scope__init(instrumentation_scope);
+
+    return instrumentation_scope;
+}
+
+static Opentelemetry__Proto__Common__V1__InstrumentationScope *set_instrumentation_scope(struct ctrace_instrumentation_scope *instrumentation_scope)
+{
+    Opentelemetry__Proto__Common__V1__InstrumentationScope *otel_scope;
+
+    otel_scope = initialize_instrumentation_scope();
+    if (!otel_scope) {
+        return NULL;
+    }
+
+    otel_scope->name = instrumentation_scope->name;
+    otel_scope->version = instrumentation_scope->version;
+    otel_scope->n_attributes = get_attributes_count(instrumentation_scope->attr);
+    otel_scope->dropped_attributes_count = instrumentation_scope->dropped_attr_count;
+    otel_scope->attributes = set_attributes_from_ctr(instrumentation_scope->attr);;
+
+    return otel_scope;
+}
+
+static Opentelemetry__Proto__Trace__V1__ScopeSpans **initialize_scope_spans(size_t count)
+{
+    Opentelemetry__Proto__Trace__V1__ScopeSpans **scope_spans;
+
+    scope_spans = calloc(count, sizeof(Opentelemetry__Proto__Trace__V1__ScopeSpans *));
+    if (!scope_spans) {
+        ctr_errno();
+        return NULL;
+    }
+
+    return scope_spans;
+}
+
+static Opentelemetry__Proto__Trace__V1__ScopeSpans *initialize_scope_span()
+{
+    Opentelemetry__Proto__Trace__V1__ScopeSpans *scope_span;
+
+    scope_span = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__ScopeSpans));
+    if (!scope_span) {
+        ctr_errno();
+        return NULL;
+    }
+
+    opentelemetry__proto__trace__v1__scope_spans__init(scope_span);
+
+    return scope_span;
+}
+
+static Opentelemetry__Proto__Trace__V1__ScopeSpans **set_scope_spans(struct ctrace_resource_span *resource_span)
+{
+    int span_count;
+    int scope_span_count;
+    int scope_span_index;
+    struct cfl_list *head;
+    struct ctrace_scope_span *scope_span;
+
+    Opentelemetry__Proto__Trace__V1__ScopeSpans **scope_spans;
+    Opentelemetry__Proto__Trace__V1__ScopeSpans *otel_scope_span;
+
+
+    scope_span_count = cfl_list_size(&resource_span->scope_spans);
+    scope_spans = initialize_scope_spans(scope_span_count);
+    if (!scope_spans) {
+        return NULL;
+    }
+
+    scope_span_index = 0;
+
+    cfl_list_foreach(head, &resource_span->scope_spans) {
+        scope_span = cfl_list_entry(head, struct ctrace_scope_span, _head);
+
+        otel_scope_span = initialize_scope_span();
+        if (!otel_scope_span) {
+            return NULL;
+        }
+
+        otel_scope_span->schema_url = scope_span->schema_url;
+        otel_scope_span->scope = set_instrumentation_scope(scope_span->instrumentation_scope);
+
+        span_count = cfl_list_size(&scope_span->spans);
+        otel_scope_span->n_spans = span_count;
+        otel_scope_span->spans = set_spans(scope_span);
+
+        scope_spans[scope_span_index++] = otel_scope_span;
+    }
+
+    return scope_spans;
+}
+
+static Opentelemetry__Proto__Trace__V1__ResourceSpans **initialize_resource_spans(size_t count)
+{
+    Opentelemetry__Proto__Trace__V1__ResourceSpans **resource_spans;
+
+    resource_spans = calloc(count, sizeof(Opentelemetry__Proto__Trace__V1__ResourceSpans *));
+    if (!resource_spans) {
+        ctr_errno();
+        return NULL;
+    }
+
+    return resource_spans;
+}
+
+static Opentelemetry__Proto__Trace__V1__ResourceSpans *initialize_resource_span()
+{
+    Opentelemetry__Proto__Trace__V1__ResourceSpans *resource_span;
+
+    resource_span = calloc(1, sizeof(Opentelemetry__Proto__Trace__V1__ResourceSpans));
+    if (!resource_span) {
+        ctr_errno();
+        return NULL;
+    }
+
+    opentelemetry__proto__trace__v1__resource_spans__init(resource_span);
+
+    return resource_span;
+}
+
+
+static Opentelemetry__Proto__Trace__V1__ResourceSpans **set_resource_spans(struct ctrace *ctr)
+{
+    struct ctrace_resource_span *resource_span;
+    struct cfl_list *head;
+    int resource_span_count;
+    int resource_span_index;
+
+    Opentelemetry__Proto__Trace__V1__ResourceSpans **rs;
+    Opentelemetry__Proto__Trace__V1__ResourceSpans *otel_resource_span;
+    Opentelemetry__Proto__Trace__V1__ScopeSpans **scope_spans;
+
+    resource_span_count = cfl_list_size(&ctr->resource_spans);
+    rs = initialize_resource_spans(resource_span_count);
+
+    resource_span_index = 0;
+
+    cfl_list_foreach(head, &ctr->resource_spans) {
+        resource_span = cfl_list_entry(head, struct ctrace_resource_span, _head);
+
+        otel_resource_span = initialize_resource_span();
+        if (!otel_resource_span) {
+            return NULL;
+        }
+        otel_resource_span->resource = ctr_set_resource(resource_span->resource);
+
+        otel_resource_span->n_scope_spans = cfl_list_size(&resource_span->scope_spans);
+        scope_spans = set_scope_spans(resource_span);
+        otel_resource_span->scope_spans = scope_spans;
+
+        otel_resource_span->schema_url = resource_span->schema_url;
+        rs[resource_span_index++] = otel_resource_span;
+    }
+
+    return rs;
+
+}
+
+static Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *initialize_export_service_request()
+{
+    Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *req;
+
+    req = malloc(sizeof(Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest));
+    if (!req) {
+        ctr_errno();
+        return NULL;
+    }
+    opentelemetry__proto__collector__trace__v1__export_trace_service_request__init(req);
+
+    return req;
+}
+
+static Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *create_export_service_request(struct ctrace *ctr)
+{
+    Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *req;
+    Opentelemetry__Proto__Trace__V1__ResourceSpans **rs;
+
+    req = initialize_export_service_request();
+    if (!req) {
+        return NULL;
+    }
+
+    req->n_resource_spans = cfl_list_size(&ctr->resource_spans);
+    rs = set_resource_spans(ctr);
+    req->resource_spans = rs;
+
+    return req;
+}
+
+static void destroy_attributes(Opentelemetry__Proto__Common__V1__KeyValue **attributes, size_t count)
+{
+    otlp_kvpair_list_destroy(attributes, count);
+}
+
+static void destroy_resource(Opentelemetry__Proto__Resource__V1__Resource *resource)
+{
+    destroy_attributes(resource->attributes, resource->n_attributes);
+
+    resource->attributes = NULL;
+    resource->n_attributes = 0;
+    resource->dropped_attributes_count = 0;
+
+    free(resource);
+}
+
+static void destroy_id(ProtobufCBinaryData id){
+    id.len = 0;
+
+    if (id.data) {
+        id.data = NULL;
+    }
+}
+
+static void destroy_event(Opentelemetry__Proto__Trace__V1__Span__Event *event)
+{
+    destroy_attributes(event->attributes, event->n_attributes);
+
+    event->time_unix_nano = 0;
+    event->name = NULL;
+    event->attributes = NULL;
+    event->n_attributes = 0;
+    event->dropped_attributes_count = 0;
+
+    free(event);
+}
+
+static void destroy_events(Opentelemetry__Proto__Trace__V1__Span__Event **events, size_t count)
+{
+    int event_index;
+    Opentelemetry__Proto__Trace__V1__Span__Event *event;
+
+    for (event_index = 0; event_index < count; event_index++) {
+        event = events[event_index];
+        destroy_event(event);
+    }
+
+    free(events);
+}
+
+static void destroy_link(Opentelemetry__Proto__Trace__V1__Span__Link *link)
+{
+    destroy_attributes(link->attributes, link->n_attributes);
+
+    destroy_id(link->trace_id);
+    destroy_id(link->span_id);
+
+    link->trace_state = NULL;
+    link->attributes = NULL;
+    link->n_attributes = 0;
+    link->dropped_attributes_count = 0;
+
+    free(link);
+}
+
+
+static void destroy_links(Opentelemetry__Proto__Trace__V1__Span__Link **links, size_t count)
+{
+    int link_index;
+    Opentelemetry__Proto__Trace__V1__Span__Link *link;
+
+    for (link_index = 0; link_index < count; link_index++) {
+        link = links[link_index];
+        destroy_link(link);
+    }
+
+    free(links);
+}
+
+static void destroy_span(Opentelemetry__Proto__Trace__V1__Span *span)
+{
+    destroy_events(span->events, span->n_events);
+    destroy_attributes(span->attributes, span->n_attributes);
+    destroy_links(span->links, span->n_links);
+
+    span->attributes = NULL;
+    span->n_attributes = 0;
+    span->dropped_attributes_count = 0;
+
+    span->events = NULL;
+    span->n_events = 0;
+    span->dropped_events_count = 0;
+
+    span->links = NULL;
+    span->n_links = 0;
+    span->dropped_links_count = 0;
+
+    span->start_time_unix_nano = 0;
+    span->end_time_unix_nano = 0;
+
+    destroy_id(span->trace_id);
+    destroy_id(span->span_id);
+    destroy_id(span->parent_span_id);
+    span->trace_state = NULL;
+
+    span->name = NULL;
+    span->kind = 0;
+
+    span->status->message = NULL;
+    span->status->code = 0;
+    free(span->status);
+
+    free(span);
+}
+
+static void destroy_spans(Opentelemetry__Proto__Trace__V1__Span **spans, size_t count)
+{
+    int span_index;
+
+    for (span_index = 0; span_index < count; span_index++) {
+        destroy_span(spans[span_index]);
+    }
+
+    free(spans);
+}
+
+static void destroy_scope(Opentelemetry__Proto__Common__V1__InstrumentationScope *scope)
+{
+    if (scope->name) {
+        scope->name = NULL;
+    }
+
+    scope->version = NULL;
+
+    destroy_attributes(scope->attributes, scope->n_attributes);
+    scope->attributes = NULL;
+    scope->n_attributes = 0;
+    scope->dropped_attributes_count = 0;
+
+    free(scope);
+}
+
+static void destroy_scope_span(Opentelemetry__Proto__Trace__V1__ScopeSpans *scope_span)
+{
+    if (scope_span->schema_url) {
+        scope_span->schema_url = NULL;
+    }
+
+    if (scope_span->scope) {
+        destroy_scope(scope_span->scope);
+    }
+
+    destroy_spans(scope_span->spans, scope_span->n_spans);
+    scope_span->spans = NULL;
+    scope_span->n_spans = 0;
+
+    free(scope_span);
+}
+
+static void destroy_scope_spans(Opentelemetry__Proto__Trace__V1__ScopeSpans **scope_spans,
+                         size_t count)
+{
+    int scope_span_index;
+    Opentelemetry__Proto__Trace__V1__ScopeSpans *scope_span;
+
+    for (scope_span_index = 0; scope_span_index < count; scope_span_index++) {
+        scope_span = scope_spans[scope_span_index];
+        destroy_scope_span(scope_span);
+    }
+
+    free(scope_spans);
+}
+
+static void destroy_resource_spans(Opentelemetry__Proto__Trace__V1__ResourceSpans **rs,
+                            int resource_span_count)
+{
+    Opentelemetry__Proto__Trace__V1__ResourceSpans *resource_span;
+    int resource_span_index;
+
+    for(resource_span_index = 0; resource_span_index < resource_span_count; resource_span_index++) {
+        resource_span = rs[resource_span_index];
+
+        destroy_resource(resource_span->resource);
+        resource_span->resource = NULL;
+
+        destroy_scope_spans(resource_span->scope_spans, resource_span->n_scope_spans);
+        resource_span->scope_spans = NULL;
+        resource_span->n_scope_spans = 0;
+        resource_span->schema_url = NULL;
+
+        free(resource_span);
+    }
+    free(rs);
+}
+
+static void destroy_export_service_request(Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *req)
+{
+    destroy_resource_spans(req->resource_spans, req->n_resource_spans);
+    req->n_resource_spans = 0;
+    req->resource_spans = NULL;
+
+    free(req);
+    req = NULL;
+}
+
+cfl_sds_t ctr_encode_opentelemetry_create(struct ctrace *ctr)
+{
+    cfl_sds_t buf;
+    size_t len;
+    Opentelemetry__Proto__Collector__Trace__V1__ExportTraceServiceRequest *req;
+
+    req = create_export_service_request(ctr);
+
+    len = opentelemetry__proto__collector__trace__v1__export_trace_service_request__get_packed_size(req);
+    buf = cfl_sds_create_size(len);
+    if (!buf) {
+        return NULL;
+    }
+    cfl_sds_set_len(buf, len);
+
+    opentelemetry__proto__collector__trace__v1__export_trace_service_request__pack(req, (uint8_t *)buf);
+
+    destroy_export_service_request(req);
+
+    return buf;
+}
+
+void ctr_encode_opentelemetry_destroy(cfl_sds_t text)
+{
+    cfl_sds_destroy(text);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_encode_text.c b/fluent-bit/lib/ctraces/src/ctr_encode_text.c
new file mode 100644
index 000000000..aebfd9d76
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_encode_text.c
@@ -0,0 +1,449 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+static inline void sds_cat_safe(cfl_sds_t *buf, char *str)
+{
+    int len;
+
+    len = strlen(str);
+    cfl_sds_cat_safe(buf, str, len);
+}
+
+static void format_string(cfl_sds_t *buf, cfl_sds_t val, int level)
+{
+    char tmp[1024];
+
+    snprintf(tmp, sizeof(tmp) - 1, "'%s'", val);
+    sds_cat_safe(buf, tmp);
+}
+
+static void format_int64(cfl_sds_t *buf, int64_t val, int level)
+{
+    char tmp[1024];
+
+    snprintf(tmp, sizeof(tmp) - 1, "%" PRIi64, val);
+    sds_cat_safe(buf, tmp);
+}
+
+static void format_double(cfl_sds_t *buf, double val, int level)
+{
+    char tmp[1024];
+
+    snprintf(tmp, sizeof(tmp) - 1, "%.17g", val);
+    sds_cat_safe(buf, tmp);
+}
+
+static void format_bool(cfl_sds_t *buf, int val, int level)
+{
+    if (val) {
+        sds_cat_safe(buf, "true");
+    }
+    else {
+        sds_cat_safe(buf, "false");
+    }
+}
+
+static void format_array(cfl_sds_t *buf, struct cfl_array *array, int level)
+{
+    int i;
+    int off = level + 4;
+    char tmp[128];
+    struct cfl_variant *v;
+
+    sds_cat_safe(buf, "[\n");
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s", off, "");
+
+    for (i = 0; i < array->entry_count; i++) {
+        v = array->entries[i];
+
+        sds_cat_safe(buf, tmp);
+
+        if (v->type == CFL_VARIANT_STRING) {
+            format_string(buf, v->data.as_string, off);
+        }
+        else if (v->type == CFL_VARIANT_BOOL) {
+            format_bool(buf, v->data.as_bool, off);
+        }
+        else if (v->type == CFL_VARIANT_INT) {
+            format_int64(buf, v->data.as_int64, off);
+        }
+        else if (v->type == CFL_VARIANT_DOUBLE) {
+            format_double(buf, v->data.as_double, off);
+        }
+        else if (v->type == CFL_VARIANT_ARRAY) {
+            format_array(buf, v->data.as_array, off);
+        }
+
+        if (i + 1 < array->entry_count) {
+            sds_cat_safe(buf, ",\n");
+        }
+    }
+
+    off = level;
+    snprintf(tmp, sizeof(tmp) - 1, "\n%*s]", off, "");
+    sds_cat_safe(buf, tmp);
+}
+
+static void format_attributes(cfl_sds_t *buf, struct cfl_kvlist *kv, int level)
+{
+    int off = level + 4;
+    char tmp[1024];
+    struct cfl_list *head;
+    struct cfl_kvpair *p;
+    struct cfl_variant *v;
+
+    sds_cat_safe(buf, "\n");
+
+    cfl_list_foreach(head, &kv->list) {
+        p = cfl_list_entry(head, struct cfl_kvpair, _head);
+
+        /* key */
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- %s: ", off, "", p->key);
+        sds_cat_safe(buf, tmp);
+
+        /* value */
+        v = p->val;
+        if (v->type == CFL_VARIANT_STRING) {
+            format_string(buf, v->data.as_string, off);
+        }
+        else if (v->type == CFL_VARIANT_BOOL) {
+            format_bool(buf, v->data.as_bool, off);
+        }
+        else if (v->type == CFL_VARIANT_INT) {
+            format_int64(buf, v->data.as_int64, off);
+        }
+        else if (v->type == CFL_VARIANT_DOUBLE) {
+            format_double(buf, v->data.as_double, off);
+        }
+        else if (v->type == CFL_VARIANT_ARRAY) {
+            format_array(buf, v->data.as_array, off);
+        }
+        else if (v->type == CFL_VARIANT_KVLIST) {
+            format_attributes(buf, v->data.as_kvlist, off);
+        }
+
+        sds_cat_safe(buf, "\n");
+    }
+}
+
+static void format_event(cfl_sds_t *buf, struct ctrace_span_event *event, int level)
+{
+    int off = level + 4;
+    char tmp[1024];
+
+    sds_cat_safe(buf, "\n");
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- name: %s\n", off, "", event->name);
+    sds_cat_safe(buf, tmp);
+    off += 4;
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- timestamp               : %" PRIu64 "\n", off, "", event->time_unix_nano);
+    sds_cat_safe(buf, tmp);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- dropped_attributes_count: %" PRIu32 "\n", off, "", event->dropped_attr_count);
+    sds_cat_safe(buf, tmp);
+
+    if (ctr_attributes_count(event->attr) > 0) {
+
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes:", off, "");
+        sds_cat_safe(buf, tmp);
+
+        format_attributes(buf, event->attr->kv, off);
+    }
+    else {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes: none\n", off, "");
+        sds_cat_safe(buf, tmp);
+    }
+
+}
+
+static void format_span(cfl_sds_t *buf, struct ctrace *ctx, struct ctrace_span *span, int level)
+{
+    int min;
+    int off = 1 + (level * 4);
+    char tmp[1024];
+    cfl_sds_t id_hex;
+    struct ctrace_span_event *event;
+    struct ctrace_link *link;
+    struct cfl_list *head;
+
+    min = off + 4;
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s[span '%s']\n", off, "", span->name);
+    sds_cat_safe(buf, tmp);
+
+    /* trace_id */
+    if (span->trace_id) {
+        id_hex = ctr_id_to_lower_base16(span->trace_id);
+    }
+    else {
+        id_hex = cfl_sds_create(CTR_ID_TRACE_DEFAULT);
+    }
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- trace_id                : %s\n", min, "", id_hex);
+    sds_cat_safe(buf, tmp);
+    cfl_sds_destroy(id_hex);
+
+    /* span_id */
+    if (span->span_id) {
+        id_hex = ctr_id_to_lower_base16(span->span_id);
+    }
+    else {
+        id_hex = cfl_sds_create(CTR_ID_SPAN_DEFAULT);
+    }
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- span_id                 : %s\n", min, "", id_hex);
+    sds_cat_safe(buf, tmp);
+    cfl_sds_destroy(id_hex);
+
+    /* parent_span_id */
+    if (span->parent_span_id) {
+        id_hex = ctr_id_to_lower_base16(span->parent_span_id);
+    }
+    else {
+        id_hex = cfl_sds_create("undefined");
+    }
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- parent_span_id          : %s\n", min, "", id_hex);
+    sds_cat_safe(buf, tmp);
+    cfl_sds_destroy(id_hex);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- kind                    : %i (%s)\n", min, "",
+             span->kind, ctr_span_kind_string(span));
+    sds_cat_safe(buf, tmp);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- start_time              : %" PRIu64 "\n", min, "",
+             span->start_time_unix_nano);
+    sds_cat_safe(buf, tmp);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- end_time                : %" PRIu64 "\n", min, "",
+             span->end_time_unix_nano);
+    sds_cat_safe(buf, tmp);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- dropped_attributes_count: %" PRIu32 "\n", min, "",
+             span->dropped_attr_count);
+    sds_cat_safe(buf, tmp);
+
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- dropped_events_count    : %" PRIu32 "\n", min, "",
+             span->dropped_events_count);
+    sds_cat_safe(buf, tmp);
+
+    /* Status */
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- status:\n", min, "");
+    sds_cat_safe(buf, tmp);
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- code        : %i\n", min + 4, "", span->status.code);
+    sds_cat_safe(buf, tmp);
+
+    if (span->status.message) {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- message : '%s'\n", min + 4, "", span->status.message);
+    }
+
+    /* span attributes */
+    if (ctr_attributes_count(span->attr) == 0) {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes: none\n", min, "");
+        sds_cat_safe(buf, tmp);
+    }
+    else {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes: ", min, "");
+        sds_cat_safe(buf, tmp);
+        format_attributes(buf, span->attr->kv, min);
+    }
+
+    /* events */
+    if (cfl_list_size(&span->events) == 0) {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- events: none\n", min, "");
+        sds_cat_safe(buf, tmp);
+    }
+    else {
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- events: ", min, "");
+        sds_cat_safe(buf, tmp);
+
+        cfl_list_foreach(head, &span->events) {
+            event = cfl_list_entry(head, struct ctrace_span_event, _head);
+            format_event(buf, event, min);
+        }
+    }
+
+    /* links */
+    snprintf(tmp, sizeof(tmp) - 1, "%*s- [links]\n", min, "");
+    sds_cat_safe(buf, tmp);
+
+    cfl_list_foreach(head, &span->links) {
+        link = cfl_list_entry(head, struct ctrace_link, _head);
+
+        off = min + 4;
+
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- link:\n", off, "");
+        sds_cat_safe(buf, tmp);
+
+        off += 4;
+
+        /* trace_id */
+        if (link->trace_id) {
+            id_hex = ctr_id_to_lower_base16(link->trace_id);
+        }
+        else {
+            id_hex = cfl_sds_create(CTR_ID_TRACE_DEFAULT);
+        }
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- trace_id             : %s\n", off, "", id_hex);
+        sds_cat_safe(buf, tmp);
+        cfl_sds_destroy(id_hex);
+
+        /* span_id */
+        if (link->span_id) {
+            id_hex = ctr_id_to_lower_base16(link->span_id);
+        }
+        else {
+            id_hex = cfl_sds_create(CTR_ID_SPAN_DEFAULT);
+        }
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- span_id              : %s\n", off, "", id_hex);
+        sds_cat_safe(buf, tmp);
+        cfl_sds_destroy(id_hex);
+
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- trace_state          : %s\n", off, "", link->trace_state);
+        sds_cat_safe(buf, tmp);
+
+        snprintf(tmp, sizeof(tmp) - 1, "%*s- dropped_events_count : %" PRIu32 "\n", off, "", link->dropped_attr_count);
+        sds_cat_safe(buf, tmp);
+
+        /* link attributes */
+        if (!link->attr) {
+            snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes           : none\n", off, "");
+            sds_cat_safe(buf, tmp);
+        }
+        else {
+            snprintf(tmp, sizeof(tmp) - 1, "%*s- attributes           : ", off, "");
+            sds_cat_safe(buf, tmp);
+            format_attributes(buf, span->attr->kv, off);
+        }
+    }
+}
+
+static void format_spans(cfl_sds_t *buf, struct ctrace *ctx, struct cfl_list *spans)
+{
+    struct cfl_list *head;
+    struct ctrace_span *span;
+
+    cfl_sds_printf(buf, "    [spans]\n");
+
+    /* look for spans that belongs to the given resource */
+    cfl_list_foreach(head, spans){
+        span = cfl_list_entry(head, struct ctrace_span, _head);
+
+        /* skip resource if there is no match */
+        format_span(buf, ctx, span, 2);
+    }
+}
+
+static void format_instrumentation_scope(cfl_sds_t *buf,
+                                         struct ctrace_instrumentation_scope *scope)
+{
+    cfl_sds_printf(buf, "    instrumentation scope:\n");
+    cfl_sds_printf(buf, "        - name                    : %s\n", scope->name);
+    cfl_sds_printf(buf, "        - version                 : %s\n", scope->version);
+    cfl_sds_printf(buf, "        - dropped_attributes_count: %i\n", scope->dropped_attr_count);
+
+    if (scope->attr) {
+        cfl_sds_printf(buf, "        - attributes:\n");
+        format_attributes(buf, scope->attr->kv, 8);
+    }
+    else {
+        cfl_sds_printf(buf, "        - attributes: undefined\n");
+    }
+}
+
+static void format_resource(cfl_sds_t *buf, struct ctrace *ctx, struct ctrace_resource *resource)
+{
+    cfl_sds_printf(buf, "  resource:\n");
+    cfl_sds_printf(buf, "     - attributes:");
+    format_attributes(buf, resource->attr->kv, 8);
+    cfl_sds_printf(buf, "     - dropped_attributes_count: %" PRIu32 "\n", resource->dropped_attr_count);
+}
+
+static void format_scope_spans(cfl_sds_t *buf, struct ctrace *ctx, struct cfl_list *scope_spans)
+{
+    struct cfl_list *head;
+    struct ctrace_scope_span *scope_span;
+
+    cfl_list_foreach(head, scope_spans) {
+        scope_span = cfl_list_entry(head, struct ctrace_scope_span, _head);
+
+        cfl_sds_printf(buf, "  [scope_span]\n");
+
+        /* format 'instrumentation_scope' if set */
+        if (scope_span->instrumentation_scope) {
+            format_instrumentation_scope(buf, scope_span->instrumentation_scope);
+        }
+
+        /* schema_url */
+        if (scope_span->schema_url) {
+            cfl_sds_printf(buf, "    schema_url: %s\n", scope_span->schema_url);
+        }
+        else {
+            cfl_sds_printf(buf, "    schema_url: \"\"\n");
+        }
+
+        /* spans */
+        format_spans(buf, ctx, &scope_span->spans);
+    }
+}
+
+cfl_sds_t ctr_encode_text_create(struct ctrace *ctx)
+{
+    cfl_sds_t buf;
+    struct cfl_list *head;
+    struct ctrace_resource_span *resource_span;
+
+    buf = cfl_sds_create_size(1024);
+    if (!buf) {
+        return NULL;
+    }
+
+    /* iterate resource_spans */
+    cfl_list_foreach(head, &ctx->resource_spans) {
+        resource_span = cfl_list_entry(head, struct ctrace_resource_span, _head);
+
+        sds_cat_safe(&buf, "|-------------------- RESOURCE SPAN --------------------|\n");
+
+        if (resource_span->resource) {
+            format_resource(&buf, ctx, resource_span->resource);
+        }
+        else {
+            cfl_sds_printf(&buf, "  resource: {}\n");
+        }
+
+        /* schema_url */
+        if (resource_span->schema_url) {
+            cfl_sds_printf(&buf, "  schema_url: %s\n", resource_span->schema_url);
+        }
+        else {
+            cfl_sds_printf(&buf, "  schema_url: \"\"\n");
+        }
+
+        /* scope spans */
+        format_scope_spans(&buf, ctx, &resource_span->scope_spans);
+    }
+
+    return buf;
+}
+
+void ctr_encode_text_destroy(cfl_sds_t text)
+{
+    cfl_sds_destroy(text);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_id.c b/fluent-bit/lib/ctraces/src/ctr_id.c
new file mode 100644
index 000000000..0c2299fcd
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_id.c
@@ -0,0 +1,255 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+/* create an ID with random bytes of length CTR_ID_BUFFER_SIZE (16 bytes) */
+struct ctrace_id *ctr_id_create_random(size_t size)
+{
+    char *buf;
+    ssize_t ret;
+    struct ctrace_id *cid;
+
+    if (size <= 0) {
+        size = CTR_ID_DEFAULT_SIZE;
+    }
+
+    buf = calloc(1, size);
+    if (!buf) {
+        ctr_errno();
+        return NULL;
+    }
+
+    ret = ctr_random_get(buf, size);
+    if (ret < 0) {
+        free(buf);
+        return NULL;
+    }
+
+    cid = ctr_id_create(buf, size);
+    free(buf);
+
+    return cid;
+}
+
+void ctr_id_destroy(struct ctrace_id *cid)
+{
+    cfl_sds_destroy(cid->buf);
+    free(cid);
+}
+
+struct ctrace_id *ctr_id_create(void *buf, size_t len)
+{
+    int ret;
+    struct ctrace_id *cid;
+
+    if (len <= 0) {
+        return NULL;
+    }
+
+    cid = calloc(1, sizeof(struct ctrace_id));
+    if (!cid) {
+        ctr_errno();
+        return NULL;
+    }
+
+    ret = ctr_id_set(cid, buf, len);
+    if (ret == -1) {
+        free(cid);
+        return NULL;
+    }
+
+    return cid;
+}
+
+int ctr_id_set(struct ctrace_id *cid, void *buf, size_t len)
+{
+    if (cid->buf) {
+        cfl_sds_destroy(cid->buf);
+    }
+
+    cid->buf = cfl_sds_create_len(buf, len);
+    if (!cid->buf) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int ctr_id_cmp(struct ctrace_id *cid1, struct ctrace_id *cid2)
+{
+    int len1;
+    int len2;
+
+    if (!cid1 || !cid2) {
+        return -1;
+    }
+
+    len1 = cfl_sds_len(cid1->buf);
+    len2 = cfl_sds_len(cid2->buf);
+
+    if (len1 != len2) {
+        return -1;
+    }
+
+    if (memcmp(cid1->buf, cid2->buf, len1) == 0) {
+        return 0;
+    }
+
+    return -1;
+}
+
+size_t ctr_id_get_len(struct ctrace_id *cid)
+{
+    return cfl_sds_len(cid->buf);
+}
+
+void *ctr_id_get_buf(struct ctrace_id *cid)
+{
+    return cid->buf;
+}
+
+cfl_sds_t ctr_id_to_lower_base16(struct ctrace_id *cid)
+{
+    int i;
+    int len;
+    cfl_sds_t out;
+    const char hex[] = "0123456789abcdef";
+
+    if (!cid->buf) {
+        return NULL;
+    }
+
+    len = cfl_sds_len(cid->buf);
+    out = cfl_sds_create_size(len * 2 + 1);
+    if (!out) {
+        return NULL;
+    }
+
+    for (i = 0; i < len; i++) {
+        out[i * 2] = hex[(cid->buf[i] >> 4) & 0xF];
+        out[i * 2 + 1] = hex[(cid->buf[i] >> 0) & 0xF];
+    }
+
+    out[i * 2] = 0;
+
+    return out;
+}
+
+/* This function returns CFL_TRUE on success and CFL_FALSE on
+ * failure.
+ */
+static int decode_hex_digit(char *digit)
+{
+    if (*digit >= '0' && *digit <= '9') {
+        *digit -= '0';
+    }
+    else if (*digit >= 'a' && *digit <= 'f') {
+        *digit -= 'a';
+        *digit += 10;
+    }
+    else if (*digit >= 'A' && *digit <= 'F') {
+        *digit -= 'A';
+        *digit += 10;
+    }
+    else {
+        return CFL_FALSE;
+    }
+
+    return CFL_TRUE;
+}
+
+struct ctrace_id *ctr_id_from_base16(cfl_sds_t id)
+{
+    size_t            output_index;
+    size_t            input_index;
+    cfl_sds_t         decoded_id;
+    struct ctrace_id *result_id;
+    int               result;
+    size_t            length;
+    char              digit;
+    char              value;
+
+    if (id == NULL) {
+        return NULL;
+    }
+
+    length = cfl_sds_len(id);
+
+    if (length < 2) {
+        return NULL;
+    }
+
+    if ((length % 2) != 0) {
+        return NULL;
+    }
+
+    decoded_id = cfl_sds_create_size(length / 2);
+
+    if (decoded_id == NULL) {
+        return NULL;
+    }
+
+    output_index = 0;
+    input_index = 0;
+    value = 0;
+
+    /* This loop consumes one character per iteration,
+     * on each iteration it verifies that the character
+     * corresponds to the base16 charset and then
+     * it subtracts the correct base to get a number
+     * ranging from 0 to 16.
+     * Then the accumulator is left shifted 4 bits and
+     * the current value is bitwise ORed to its value.
+     * If the character index is odd then the accumulator
+     * value is appended to the decoded id buffer and
+     * reinitialized to be used on the next iteration.
+    */
+
+    while (input_index < length) {
+        digit = id[input_index];
+        result = decode_hex_digit(&digit);
+
+        if (!result) {
+            break;
+        }
+
+        digit  &= 0xF;
+        value <<= 4;
+        value  |= digit;
+
+        if ((input_index % 2) == 1) {
+            decoded_id[output_index++] = value;
+            value = 0;
+        }
+
+        input_index++;
+    }
+
+    if (result) {
+        result_id = ctr_id_create(decoded_id, length / 2);
+    }
+    else {
+        result_id = NULL;
+    }
+
+    cfl_sds_destroy(decoded_id);
+
+    return result_id;
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_link.c b/fluent-bit/lib/ctraces/src/ctr_link.c
new file mode 100644
index 000000000..9f92c3aa5
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_link.c
@@ -0,0 +1,142 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+struct ctrace_link *ctr_link_create(struct ctrace_span *span,
+                                    void *trace_id_buf, size_t trace_id_len,
+                                    void *span_id_buf, size_t span_id_len)
+{
+    struct ctrace_link *link;
+
+    link = calloc(1, sizeof(struct ctrace_link));
+    if (!link) {
+        ctr_errno();
+        return NULL;
+    }
+
+    /* trace_id */
+    if (trace_id_buf && trace_id_len > 0) {
+        link->trace_id = ctr_id_create(trace_id_buf, trace_id_len);
+        if (!link->trace_id) {
+            free(link);
+            return NULL;
+        }
+    }
+
+    /* span_id */
+    if (span_id_buf && span_id_len > 0) {
+        link->span_id = ctr_id_create(span_id_buf, span_id_len);
+        if (!link->span_id) {
+            ctr_id_destroy(link->trace_id);
+            free(link);
+            return NULL;
+        }
+    }
+
+    cfl_list_add(&link->_head, &span->links);
+    return link;
+}
+
+struct ctrace_link *ctr_link_create_with_cid(struct ctrace_span *span,
+                                             struct ctrace_id *trace_id_cid,
+                                             struct ctrace_id *span_id_cid)
+{
+    size_t trace_id_len = 0;
+    size_t span_id_len = 0;
+    void *trace_id_buf = NULL;
+    void *span_id_buf = NULL;
+
+    if (trace_id_cid) {
+        trace_id_buf = ctr_id_get_buf(trace_id_cid);
+        trace_id_len = ctr_id_get_len(trace_id_cid);
+    }
+
+    if (span_id_cid) {
+        span_id_buf = ctr_id_get_buf(span_id_cid);
+        span_id_len = ctr_id_get_len(span_id_cid);
+    }
+
+    return ctr_link_create(span, trace_id_buf, trace_id_len, span_id_buf, span_id_len);
+}
+
+int ctr_link_set_trace_state(struct ctrace_link *link, char *trace_state)
+{
+    if (!link || !trace_state) {
+        return -1;
+    }
+
+    link->trace_state = cfl_sds_create(trace_state);
+    if (!link->trace_state) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int ctr_link_set_attributes(struct ctrace_link *link, struct ctrace_attributes *attr)
+{
+    if (!attr) {
+        return -1;
+    }
+
+    link->attr = attr;
+    return 0;
+}
+
+void ctr_link_set_dropped_attr_count(struct ctrace_link *link, uint32_t count)
+{
+    link->dropped_attr_count = count;
+}
+
+void ctr_link_destroy(struct ctrace_link *link)
+{
+    if (link->trace_id) {
+        ctr_id_destroy(link->trace_id);
+    }
+
+    if (link->span_id) {
+        ctr_id_destroy(link->span_id);
+    }
+
+    if (link->trace_state) {
+        cfl_sds_destroy(link->trace_state);
+    }
+
+    if (link->attr) {
+        ctr_attributes_destroy(link->attr);
+    }
+
+    cfl_list_del(&link->_head);
+    free(link);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fluent-bit/lib/ctraces/src/ctr_log.c b/fluent-bit/lib/ctraces/src/ctr_log.c
new file mode 100644
index 000000000..d09e11d3a
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_log.c
@@ -0,0 +1,88 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+#include <string.h>
+#include <stdarg.h>
+
+#ifdef _WIN32
+    #define strerror_r(errnum, buf, buf_size) strerror_s(buf, buf_size, errnum)
+#endif
+
+void ctr_log_print(void *ctx, int level, const char *file, int line,
+                   const char *fmt, ...)
+{
+    int ret;
+    char buf[CTR_LOG_BUF_SIZE];
+    va_list args;
+    struct ctrace *ctr = ctx;
+
+    if (!ctr->log_cb) {
+       return;
+    }
+
+    if (level > ctr->log_level) {
+        return;
+    }
+
+    va_start(args, fmt);
+    ret = vsnprintf(buf, CTR_LOG_BUF_SIZE - 1, fmt, args);
+
+    if (ret >= 0) {
+        buf[ret] = '\0';
+    }
+    va_end(args);
+
+    ctr->log_cb(ctx, level, file, line, buf);
+}
+
+int ctr_errno_print(int errnum, const char *file, int line)
+{
+    char buf[256];
+
+    strerror_r(errnum, buf, sizeof(buf) - 1);
+    fprintf(stderr, "[%s:%i errno=%i] %s\n",
+            file, line, errnum, buf);
+    return 0;
+}
+
+#ifdef _WIN32
+void ctr_winapi_error_print(const char *func, int line)
+{
+    int error = GetLastError();
+    char buf[256];
+    int success;
+
+    success = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
+                             FORMAT_MESSAGE_IGNORE_INSERTS,
+                             NULL,
+                             error,
+                             LANG_SYSTEM_DEFAULT,
+                             buf,
+                             sizeof(buf),
+                             NULL);
+    if (success) {
+        fprintf(stderr, "[%s() line=%i error=%i] %s\n", func, line, error, buf);
+    }
+    else {
+        fprintf(stderr, "[%s() line=%i error=%i] Win32 API failed\n", func, line, error);
+    }
+}
+#endif
diff --git a/fluent-bit/lib/ctraces/src/ctr_mpack_utils.c b/fluent-bit/lib/ctraces/src/ctr_mpack_utils.c
new file mode 100644
index 000000000..222e2664f
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_mpack_utils.c
@@ -0,0 +1,488 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctr_mpack_utils.h>
+#include <cfl/cfl_sds.h>
+#include <mpack/mpack.h>
+
+int ctr_mpack_consume_string_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer)
+{
+    int result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_str) {
+        result = ctr_mpack_consume_string_tag(reader, output_buffer);
+    }
+    else if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        result = ctr_mpack_consume_nil_tag(reader);
+
+        *output_buffer = NULL;
+    }
+    else {
+        result = CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    return result;
+}
+
+int ctr_mpack_consume_binary_or_nil_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer)
+{
+    int result;
+
+    if (ctr_mpack_peek_type(reader) == mpack_type_bin) {
+        result = ctr_mpack_consume_binary_tag(reader, output_buffer);
+    }
+    else if (ctr_mpack_peek_type(reader) == mpack_type_nil) {
+        result = ctr_mpack_consume_nil_tag(reader);
+
+        *output_buffer = NULL;
+    }
+    else {
+        result = CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    return result;
+}
+
+int ctr_mpack_consume_nil_tag(mpack_reader_t *reader)
+{
+    mpack_tag_t tag;
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_nil != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_consume_double_tag(mpack_reader_t *reader, double *output_buffer)
+{
+    mpack_tag_t tag;
+
+    if (NULL == output_buffer) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_double != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    *output_buffer = mpack_tag_double_value(&tag);
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_consume_uint_tag(mpack_reader_t *reader, uint64_t *output_buffer)
+{
+    mpack_tag_t tag;
+
+    if (NULL == output_buffer) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_int == mpack_tag_type(&tag)) {
+        *output_buffer = (uint64_t) mpack_tag_int_value(&tag);
+    }
+    else if (mpack_type_uint == mpack_tag_type(&tag)) {
+        *output_buffer = (uint64_t) mpack_tag_uint_value(&tag);
+    }
+    else {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_consume_uint32_tag(mpack_reader_t *reader, uint32_t *output_buffer)
+{
+    int      result;
+    uint64_t value;
+
+    result = ctr_mpack_consume_uint_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS) {
+        *output_buffer = (uint32_t) value;
+    }
+
+    return result;
+}
+
+int ctr_mpack_consume_uint64_tag(mpack_reader_t *reader, uint64_t *output_buffer)
+{
+    return ctr_mpack_consume_uint_tag(reader, output_buffer);
+}
+
+int ctr_mpack_consume_int_tag(mpack_reader_t *reader, int64_t *output_buffer)
+{
+    mpack_tag_t tag;
+
+    if (NULL == output_buffer) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_int == mpack_tag_type(&tag)) {
+        *output_buffer = (int64_t) mpack_tag_int_value(&tag);
+    }
+    else if (mpack_type_uint == mpack_tag_type(&tag)) {
+        *output_buffer = (int64_t) mpack_tag_uint_value(&tag);
+    }
+    else {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_consume_int32_tag(mpack_reader_t *reader, int32_t *output_buffer)
+{
+    int     result;
+    int64_t value;
+
+    result = ctr_mpack_consume_int_tag(reader, &value);
+
+    if (result == CTR_MPACK_SUCCESS) {
+        *output_buffer = (int32_t) value;
+    }
+
+    return result;
+}
+
+int ctr_mpack_consume_int64_tag(mpack_reader_t *reader, int64_t *output_buffer)
+{
+    return ctr_mpack_consume_int_tag(reader, output_buffer);
+}
+
+int ctr_mpack_consume_string_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer)
+{
+    uint32_t    string_length;
+    mpack_tag_t tag;
+
+    if (NULL == output_buffer) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_str != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    string_length = mpack_tag_str_length(&tag);
+
+    /* This validation only applies to cmetrics and its use cases, we know
+     * for a fact that our label names and values are not supposed to be really
+     * long so a huge value here probably means that the data stream got corrupted.
+     */
+
+    if (CTR_MPACK_MAX_STRING_LENGTH < string_length) {
+        return CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+    }
+
+    *output_buffer = cfl_sds_create_size(string_length + 1);
+
+    if (NULL == *output_buffer) {
+        return CTR_MPACK_ALLOCATION_ERROR;
+    }
+
+    cfl_sds_set_len(*output_buffer, string_length);
+
+    mpack_read_cstr(reader, *output_buffer, string_length + 1, string_length);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        cfl_sds_destroy(*output_buffer);
+
+        *output_buffer = NULL;
+
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    mpack_done_str(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        cfl_sds_destroy(*output_buffer);
+
+        *output_buffer = NULL;
+
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_consume_binary_tag(mpack_reader_t *reader, cfl_sds_t *output_buffer)
+{
+    uint32_t    string_length;
+    mpack_tag_t tag;
+
+    if (NULL == output_buffer) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    if (NULL == reader) {
+        return CTR_MPACK_INVALID_ARGUMENT_ERROR;
+    }
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_bin != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    string_length = mpack_tag_bin_length(&tag);
+
+    *output_buffer = cfl_sds_create_size(string_length);
+
+    if (NULL == *output_buffer) {
+        return CTR_MPACK_ALLOCATION_ERROR;
+    }
+
+    cfl_sds_set_len(*output_buffer, string_length);
+
+    mpack_read_bytes(reader, *output_buffer, string_length);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        cfl_sds_destroy(*output_buffer);
+
+        *output_buffer = NULL;
+
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    mpack_done_bin(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        cfl_sds_destroy(*output_buffer);
+
+        *output_buffer = NULL;
+
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    return CTR_MPACK_SUCCESS;
+}
+
+int ctr_mpack_unpack_map(mpack_reader_t *reader,
+                         struct ctr_mpack_map_entry_callback_t *callback_list,
+                         void *context)
+{
+    struct ctr_mpack_map_entry_callback_t *callback_entry;
+    uint32_t                               entry_index;
+    uint32_t                               entry_count;
+    cfl_sds_t                              key_name;
+    int                                    result;
+    mpack_tag_t                            tag;
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader)) {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_map != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    entry_count = mpack_tag_map_count(&tag);
+
+    /* This validation only applies to cmetrics and its use cases, we know
+     * how our schema looks and how many entries the different fields have and none
+     * of those exceed the number we set CTR_MPACK_MAX_MAP_ENTRY_COUNT to which is 10.
+     * Making these sanity checks optional or configurable in runtime might be worth
+     * the itme and complexity cost but that's something I don't know at the moment.
+     */
+
+    if (CTR_MPACK_MAX_MAP_ENTRY_COUNT < entry_count) {
+        return CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+    }
+
+    result = 0;
+
+    for (entry_index = 0 ; 0 == result && entry_index < entry_count ; entry_index++) {
+        result = ctr_mpack_consume_string_tag(reader, &key_name);
+
+        if (CTR_MPACK_SUCCESS == result) {
+            callback_entry = callback_list;
+            result = CTR_MPACK_UNEXPECTED_KEY_ERROR;
+
+            while (CTR_MPACK_UNEXPECTED_KEY_ERROR == result &&
+                   NULL != callback_entry->identifier) {
+
+                if (0 == strcmp(callback_entry->identifier, key_name)) {
+                    result = callback_entry->handler(reader, entry_index, context);
+                }
+
+                callback_entry++;
+            }
+
+            cfl_sds_destroy(key_name);
+        }
+    }
+
+    if (CTR_MPACK_SUCCESS == result) {
+        mpack_done_map(reader);
+
+        if (mpack_ok != mpack_reader_error(reader))
+        {
+            return CTR_MPACK_PENDING_MAP_ENTRIES;
+        }
+    }
+
+    return result;
+}
+
+int ctr_mpack_unpack_array(mpack_reader_t *reader,
+                           ctr_mpack_unpacker_entry_callback_fn_t entry_processor_callback,
+                           void *context)
+{
+    uint32_t              entry_index;
+    uint32_t              entry_count;
+    mpack_tag_t           tag;
+    int                   result;
+
+    tag = mpack_read_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader))
+    {
+        return CTR_MPACK_ENGINE_ERROR;
+    }
+
+    if (mpack_type_array != mpack_tag_type(&tag)) {
+        return CTR_MPACK_UNEXPECTED_DATA_TYPE_ERROR;
+    }
+
+    entry_count = mpack_tag_array_count(&tag);
+
+    /* This validation only applies to cmetrics and its use cases, we know
+     * that in our schema we have the following arrays :
+     *     label text dictionary (strings)
+     *     dimension labels (indexes)
+     *     metric values
+     *         dimension values
+     *
+     * IMO none of these arrays should be huge so I think using 65535 as a limit
+     * gives us more than enough wiggle space (in reality I don't expect any of these
+     * arrays to hold more than 128 values but I could be wrong as that probably depends
+     * on the flush interval)
+     */
+
+    if (CTR_MPACK_MAX_ARRAY_ENTRY_COUNT < entry_count) {
+        return CTR_MPACK_CORRUPT_INPUT_DATA_ERROR;
+    }
+
+    result = CTR_MPACK_SUCCESS;
+
+    for (entry_index = 0 ;
+         CTR_MPACK_SUCCESS == result && entry_index < entry_count ;
+         entry_index++) {
+        result = entry_processor_callback(reader, entry_index, context);
+    }
+
+    if (CTR_MPACK_SUCCESS == result) {
+        mpack_done_array(reader);
+
+        if (mpack_ok != mpack_reader_error(reader))
+        {
+            return CTR_MPACK_PENDING_ARRAY_ENTRIES;
+        }
+    }
+
+    return result;
+}
+
+int ctr_mpack_peek_array_length(mpack_reader_t *reader)
+{
+    mpack_tag_t tag;
+
+    tag = mpack_peek_tag(reader);
+
+    if (mpack_ok != mpack_reader_error(reader))
+    {
+        return 0;
+    }
+
+    if (mpack_type_array != mpack_tag_type(&tag)) {
+        return 0;
+    }
+
+    return mpack_tag_array_count(&tag);
+}
+
+mpack_type_t ctr_mpack_peek_type(mpack_reader_t *reader)
+{
+    mpack_tag_t tag;
+
+    tag = mpack_peek_tag(reader);
+
+    if (mpack_reader_error(reader) != mpack_ok) {
+        return mpack_type_missing;
+    }
+
+    return mpack_tag_type(&tag);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_random.c b/fluent-bit/lib/ctraces/src/ctr_random.c
new file mode 100644
index 000000000..0274c238b
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_random.c
@@ -0,0 +1,86 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+#if defined(unix) || defined (__unix) || defined(__unix__) || defined(__linux__) || \
+    defined(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__ANDROID__)
+#define ITS_A_UNIX_FRIEND
+#endif
+
+#ifdef CTR_HAVE_GETRANDOM
+#include <sys/random.h>
+#endif
+
+#ifdef ITS_A_UNIX_FRIEND
+#include <fcntl.h>
+#include <unistd.h>
+#else
+// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036.  See the
+// "Community Additions" comment on MSDN here:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
+#define SystemFunction036 NTAPI SystemFunction036
+#include <ntsecapi.h>
+#undef SystemFunction036
+
+#endif
+
+#include <time.h>
+
+ssize_t ctr_random_get(void *buf, size_t len)
+{
+    int i;
+    ssize_t ret = 0;
+    unsigned int s;
+    char *tmp;
+
+#ifdef CTR_HAVE_GETRANDOM
+    /*
+     * On Linux systems getrandom() is preferred, note that our use case it's pretty
+     * simple (no security stuff).
+     */
+    ret = getrandom(buf, len, GRND_NONBLOCK);
+    return ret;
+#endif
+
+    /* if getrandom() is not available and we are on Linux, macOS or BSD, try out /dev/urandom */
+#ifdef ITS_A_UNIX_FRIEND
+    int fd;
+
+    fd = open("/dev/urandom",  O_RDONLY);
+    if (fd > 0) {
+        ret = read(fd, buf, len);
+        close(fd);
+        return ret;
+    }
+
+    s = time(NULL);
+
+    /* fallback... a very slow way to compose a random buffer */
+    tmp = buf;
+    for (i = 0; i < len; i++) {
+        /* fixme: we need a good entropy here */
+        tmp[i] = rand_r(&s);
+    }
+#else /* Windows ? */
+    ret = RtlGenRandom(buf, len);
+#endif
+
+    return ret;
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_resource.c b/fluent-bit/lib/ctraces/src/ctr_resource.c
new file mode 100644
index 000000000..718ef7bc4
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_resource.c
@@ -0,0 +1,159 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_resource.h>
+
+struct ctrace_resource *ctr_resource_create()
+{
+    struct ctrace_resource *res;
+    struct ctrace_attributes *attr;
+
+    res = calloc(1, sizeof(struct ctrace_resource));
+    if (!res) {
+        ctr_errno();
+        return NULL;
+    }
+
+    attr = ctr_attributes_create();
+    if (!attr) {
+        ctr_resource_destroy(res);
+        return NULL;
+    }
+    res->attr = attr;
+
+    return res;
+}
+
+struct ctrace_resource *ctr_resource_create_default()
+{
+    struct ctrace_resource *res;
+
+    res = ctr_resource_create();
+    if (!res) {
+        return NULL;
+    }
+
+    /* some default attributes */
+    ctr_attributes_set_string(res->attr, "service.name", "Fluent Bit");
+    ctr_attributes_set_int64(res->attr, "release_year", 2014);
+
+    return res;
+}
+
+int ctr_resource_set_attributes(struct ctrace_resource *res, struct ctrace_attributes *attr)
+{
+    if (!attr) {
+        return -1;
+    }
+
+    if (res->attr) {
+        ctr_attributes_destroy(res->attr);
+    }
+
+    res->attr = attr;
+    return 0;
+}
+
+void ctr_resource_set_dropped_attr_count(struct ctrace_resource *res, uint32_t count)
+{
+    res->dropped_attr_count = count;
+}
+
+void ctr_resource_destroy(struct ctrace_resource *res)
+{
+    if (res->attr) {
+        ctr_attributes_destroy(res->attr);
+    }
+    free(res);
+}
+
+/*
+ * resource_span API
+ * -----------------
+ */
+
+/* creates a resource_span context */
+struct ctrace_resource_span *ctr_resource_span_create(struct ctrace *ctx)
+{
+    struct ctrace_resource_span *resource_span;
+
+    resource_span = calloc(1, sizeof(struct ctrace_resource_span));
+    if (!resource_span) {
+        ctr_errno();
+        return NULL;
+    }
+    cfl_list_init(&resource_span->scope_spans);
+
+    /* link to ctraces context */
+    cfl_list_add(&resource_span->_head, &ctx->resource_spans);
+
+    /* create an empty resource */
+    resource_span->resource = ctr_resource_create();
+    if (!resource_span->resource) {
+        free(resource_span);
+        return NULL;
+    }
+
+    return resource_span;
+}
+
+struct ctrace_resource *ctr_resource_span_get_resource(struct ctrace_resource_span *resource_span)
+{
+    return resource_span->resource;
+}
+
+/* Set the schema_url for a resource_span */
+int ctr_resource_span_set_schema_url(struct ctrace_resource_span *resource_span, char *url)
+{
+    if (resource_span->schema_url) {
+        cfl_sds_destroy(resource_span->schema_url);
+    }
+
+    resource_span->schema_url = cfl_sds_create(url);
+    if (!resource_span->schema_url) {
+        return -1;
+    }
+
+    return 0;
+}
+
+void ctr_resource_span_destroy(struct ctrace_resource_span *resource_span)
+{
+    struct cfl_list *tmp;
+    struct cfl_list *head;
+    struct ctrace_scope_span *scope_span;
+
+    /* release resource if set */
+    if (resource_span->resource) {
+        ctr_resource_destroy(resource_span->resource);
+    }
+
+    if (resource_span->schema_url) {
+        cfl_sds_destroy(resource_span->schema_url);
+    }
+
+    /* remove scope spans */
+    cfl_list_foreach_safe(head, tmp, &resource_span->scope_spans) {
+        scope_span = cfl_list_entry(head, struct ctrace_scope_span, _head);
+        ctr_scope_span_destroy(scope_span);
+    }
+
+    free(resource_span);
+}
diff --git a/fluent-bit/lib/ctraces/src/ctr_scope.c b/fluent-bit/lib/ctraces/src/ctr_scope.c
new file mode 100644
index 000000000..fcb83435a
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_scope.c
@@ -0,0 +1,129 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+struct ctrace_scope_span *ctr_scope_span_create(struct ctrace_resource_span *resource_span)
+{
+    struct ctrace_scope_span *scope_span;
+
+    scope_span = calloc(1, sizeof(struct ctrace_scope_span));
+    if (!scope_span) {
+        ctr_errno();
+        return NULL;
+    }
+    cfl_list_init(&scope_span->spans);
+    cfl_list_add(&scope_span->_head, &resource_span->scope_spans);
+
+    return scope_span;
+}
+
+void ctr_scope_span_destroy(struct ctrace_scope_span *scope_span)
+{
+    struct cfl_list *tmp;
+    struct cfl_list *head;
+    struct ctrace_span *span;
+
+    /* release instrumentation scope if set */
+    if (scope_span->instrumentation_scope) {
+        ctr_instrumentation_scope_destroy(scope_span->instrumentation_scope);
+    }
+
+    /* remove linked spans */
+    cfl_list_foreach_safe(head, tmp, &scope_span->spans) {
+        span = cfl_list_entry(head, struct ctrace_span, _head);
+        ctr_span_destroy(span);
+    }
+
+    if (scope_span->schema_url) {
+        cfl_sds_destroy(scope_span->schema_url);
+    }
+
+    cfl_list_del(&scope_span->_head);
+    free(scope_span);
+}
+
+/* Set the schema_url for a resource_span */
+int ctr_scope_span_set_schema_url(struct ctrace_scope_span *scope_span, char *url)
+{
+    if (scope_span->schema_url) {
+        cfl_sds_destroy(scope_span->schema_url);
+    }
+
+    scope_span->schema_url = cfl_sds_create(url);
+    if (!scope_span->schema_url) {
+        return -1;
+    }
+
+    return 0;
+}
+
+void ctr_scope_span_set_instrumentation_scope(struct ctrace_scope_span *scope_span,
+                                              struct ctrace_instrumentation_scope *scope)
+{
+    /* Safeguard against leaks */
+    if (scope_span->instrumentation_scope != NULL) {
+        ctr_instrumentation_scope_destroy(scope_span->instrumentation_scope);
+    }
+
+    scope_span->instrumentation_scope = scope;
+}
+
+struct ctrace_instrumentation_scope *ctr_instrumentation_scope_create(char *name, char *version,
+                                                                      uint32_t dropped_attr_count,
+                                                                      struct ctrace_attributes *attr)
+{
+    struct ctrace_instrumentation_scope *ins_scope;
+
+    ins_scope = calloc(1, sizeof(struct ctrace_instrumentation_scope));
+    if (!ins_scope) {
+        ctr_errno();
+        return NULL;
+    }
+
+    if (name) {
+        ins_scope->name = cfl_sds_create(name);
+    }
+    if (version) {
+        ins_scope->version = cfl_sds_create(version);
+    }
+
+    ins_scope->dropped_attr_count = dropped_attr_count;
+    ins_scope->attr = attr;
+
+    return ins_scope;
+}
+
+void ctr_instrumentation_scope_destroy(struct ctrace_instrumentation_scope *ins_scope)
+{
+    if (ins_scope->name) {
+        cfl_sds_destroy(ins_scope->name);
+    }
+
+    if (ins_scope->version) {
+        cfl_sds_destroy(ins_scope->version);
+    }
+
+    if (ins_scope->attr) {
+        ctr_attributes_destroy(ins_scope->attr);
+    }
+
+    free(ins_scope);
+}
+
diff --git a/fluent-bit/lib/ctraces/src/ctr_span.c b/fluent-bit/lib/ctraces/src/ctr_span.c
new file mode 100644
index 000000000..d93935a72
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_span.c
@@ -0,0 +1,434 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+#include <cfl/cfl.h>
+#include <cfl/cfl_time.h>
+#include <cfl/cfl_kvlist.h>
+
+struct ctrace_span *ctr_span_create(struct ctrace *ctx, struct ctrace_scope_span *scope_span, cfl_sds_t name,
+                                    struct ctrace_span *parent)
+{
+    struct ctrace_span *span;
+
+    if (!ctx || !scope_span || !name) {
+        return NULL;
+    }
+
+    /* allocate a spanc context */
+    span = calloc(1, sizeof(struct ctrace_span));
+    if (!span) {
+        ctr_errno();
+        return NULL;
+    }
+
+    /* references */
+    span->scope_span = scope_span;
+    span->ctx = ctx;
+
+    /* name */
+    span->name = cfl_sds_create(name);
+    if (!span->name) {
+        free(span);
+        return NULL;
+    }
+
+    /* attributes */
+    span->attr = ctr_attributes_create();
+    if (!span->attr) {
+        free(span);
+        return NULL;
+    }
+    cfl_list_init(&span->events);
+    cfl_list_init(&span->links);
+
+    /* dropped attributes count */
+    span->dropped_attr_count = 0;
+
+    /* if a parent context was given, populate the span parent id */
+    if (parent && parent->span_id) {
+        ctr_span_set_parent_span_id_with_cid(span, parent->span_id);
+    }
+
+    /* link span to struct scope_span->spans */
+    cfl_list_add(&span->_head, &scope_span->spans);
+
+    /* link span to the struct ctrace->span_list */
+    cfl_list_add(&span->_head_global, &ctx->span_list);
+
+    /* set default kind */
+    ctr_span_kind_set(span, CTRACE_SPAN_INTERNAL);
+
+    /* always start a span by default, the start can be overriden later if needed */
+    ctr_span_start(ctx, span);
+    return span;
+}
+
+/* Set the Span ID with a given buffer and length */
+int ctr_span_set_trace_id(struct ctrace_span *span, void *buf, size_t len)
+{
+    if (!buf || len <= 0) {
+        return -1;
+    }
+
+    /* If trace_id is already set, free it first */
+    if (span->trace_id != NULL) {
+        ctr_id_destroy(span->trace_id);
+        span->trace_id = NULL;
+    }
+
+    span->trace_id = ctr_id_create(buf, len);
+    if (!span->trace_id) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Set the Span ID by using a ctrace_id context */
+int ctr_span_set_trace_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid)
+{
+    return ctr_span_set_trace_id(span,
+                                 ctr_id_get_buf(cid),
+                                 ctr_id_get_len(cid));
+}
+
+/* Set the Span ID with a given buffer and length */
+int ctr_span_set_span_id(struct ctrace_span *span, void *buf, size_t len)
+{
+    if (!buf || len <= 0) {
+        return -1;
+    }
+
+    span->span_id = ctr_id_create(buf, len);
+    if (!span->span_id) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Set the Span ID by using a ctrace_id context */
+int ctr_span_set_span_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid)
+{
+    return ctr_span_set_span_id(span,
+                                ctr_id_get_buf(cid),
+                                ctr_id_get_len(cid));
+}
+
+/* Set the Span Parent ID with a given buffer and length */
+int ctr_span_set_parent_span_id(struct ctrace_span *span, void *buf, size_t len)
+{
+    if (!buf || len <= 0) {
+        return -1;
+    }
+
+    if (span->parent_span_id) {
+        ctr_id_destroy(span->parent_span_id);
+    }
+
+    span->parent_span_id = ctr_id_create(buf, len);
+    if (!span->parent_span_id) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* Set the Span ID by using a ctrace_id context */
+int ctr_span_set_parent_span_id_with_cid(struct ctrace_span *span, struct ctrace_id *cid)
+{
+    return ctr_span_set_parent_span_id(span,
+                                       ctr_id_get_buf(cid),
+                                       ctr_id_get_len(cid));
+}
+
+int ctr_span_kind_set(struct ctrace_span *span, int kind)
+{
+    if (kind < CTRACE_SPAN_UNSPECIFIED || kind > CTRACE_SPAN_CONSUMER) {
+        return -1;
+    }
+
+    span->kind = kind;
+    return 0;
+}
+
+/* returns a read-only version of the Span kind */
+char *ctr_span_kind_string(struct ctrace_span *span)
+{
+    switch (span->kind) {
+        case CTRACE_SPAN_INTERNAL:
+            return "internal";
+        case CTRACE_SPAN_SERVER:
+            return "server";
+        case CTRACE_SPAN_CLIENT:
+            return "client";
+        case CTRACE_SPAN_PRODUCER:
+            return "producer";
+        case CTRACE_SPAN_CONSUMER:
+            return "consumer";
+        default:
+            return "unspecified";
+    };
+}
+
+/*
+ * Span attributes
+ * ---------------
+ */
+int ctr_span_set_attribute_string(struct ctrace_span *span, char *key, char *value)
+{
+    return ctr_attributes_set_string(span->attr, key, value);
+}
+
+int ctr_span_set_attribute_bool(struct ctrace_span *span, char *key, int b)
+{
+    return ctr_attributes_set_bool(span->attr, key, b);
+}
+
+int ctr_span_set_attribute_int64(struct ctrace_span *span, char *key, int64_t value)
+{
+    return ctr_attributes_set_int64(span->attr, key, value);
+}
+
+int ctr_span_set_attribute_double(struct ctrace_span *span, char *key, double value)
+{
+    return ctr_attributes_set_double(span->attr, key, value);
+}
+
+int ctr_span_set_attribute_array(struct ctrace_span *span, char *key,
+                                 struct cfl_array *value)
+{
+    return ctr_attributes_set_array(span->attr, key, value);
+}
+
+int ctr_span_set_attribute_kvlist(struct ctrace_span *span, char *key,
+                                  struct cfl_kvlist *value)
+{
+
+    return ctr_attributes_set_kvlist(span->attr, key, value);
+}
+
+void ctr_span_start(struct ctrace *ctx, struct ctrace_span *span)
+{
+    uint64_t ts;
+
+    ts = cfl_time_now();
+    ctr_span_start_ts(ctx, span, ts);
+}
+
+void ctr_span_start_ts(struct ctrace *ctx, struct ctrace_span *span, uint64_t ts)
+{
+    /* set the initial timestamp */
+    span->start_time_unix_nano = ts;
+
+    /* always set the span end time as the start time, so duration can be zero */
+    ctr_span_end_ts(ctx, span, ts);
+}
+
+void ctr_span_end(struct ctrace *ctx, struct ctrace_span *span)
+{
+    uint64_t ts;
+
+    ts = cfl_time_now();
+    ctr_span_end_ts(ctx, span, ts);
+}
+
+void ctr_span_end_ts(struct ctrace *ctx, struct ctrace_span *span, uint64_t ts)
+{
+    span->end_time_unix_nano = ts;
+}
+
+int ctr_span_set_status(struct ctrace_span *span, int code, char *message)
+{
+    struct ctrace_span_status *status;
+
+    status = &span->status;
+    if (status->message) {
+        cfl_sds_destroy(status->message);
+    }
+
+    if (message) {
+        status->message = cfl_sds_create(message);
+        if (!status->message) {
+            return -1;
+        }
+    }
+
+    status->code = code;
+    return 0;
+}
+
+void ctr_span_set_dropped_events_count(struct ctrace_span *span, uint32_t count)
+{
+    span->dropped_events_count = count;
+}
+
+void ctr_span_set_dropped_attributes_count(struct ctrace_span *span, uint32_t count)
+{
+    span->dropped_attr_count = count;
+}
+
+void ctr_span_destroy(struct ctrace_span *span)
+{
+    struct cfl_list *tmp;
+    struct cfl_list *head;
+    struct ctrace_span_event *event;
+    struct ctrace_span_status *status;
+    struct ctrace_link *link;
+
+    if (span->name) {
+        cfl_sds_destroy(span->name);
+    }
+
+    if (span->trace_id) {
+        ctr_id_destroy(span->trace_id);
+    }
+
+    if (span->span_id) {
+        ctr_id_destroy(span->span_id);
+    }
+
+    if (span->parent_span_id) {
+        ctr_id_destroy(span->parent_span_id);
+    }
+
+    /* attributes */
+    if (span->attr) {
+        ctr_attributes_destroy(span->attr);
+    }
+
+    /* events */
+    cfl_list_foreach_safe(head, tmp, &span->events) {
+        event = cfl_list_entry(head, struct ctrace_span_event, _head);
+        ctr_span_event_delete(event);
+    }
+
+    /* links */
+    cfl_list_foreach_safe(head, tmp, &span->links) {
+        link = cfl_list_entry(head, struct ctrace_link, _head);
+        ctr_link_destroy(link);
+    }
+
+    /* status */
+    status = &span->status;
+    if (status->message) {
+        cfl_sds_destroy(status->message);
+    }
+
+    cfl_list_del(&span->_head);
+    cfl_list_del(&span->_head_global);
+    free(span);
+}
+
+/*
+ * Span Events
+ * -----------
+ */
+struct ctrace_span_event *ctr_span_event_add_ts(struct ctrace_span *span, char *name, uint64_t ts)
+{
+    struct ctrace_span_event *ev;
+
+    if (!name) {
+        return NULL;
+    }
+
+    ev = calloc(1, sizeof(struct ctrace_span_event));
+    if (!ev) {
+        ctr_errno();
+        return NULL;
+    }
+    ev->name = cfl_sds_create(name);
+    if (!ev->name) {
+        free(ev);
+        return NULL;
+    }
+    ev->attr = ctr_attributes_create(128);
+    ev->dropped_attr_count = 0;
+
+    /* if no timestamp is given, use the current time */
+    if (ts == 0) {
+        ev->time_unix_nano = cfl_time_now();
+    }
+    else {
+        ev->time_unix_nano = ts;
+    }
+
+    cfl_list_add(&ev->_head, &span->events);
+    return ev;
+}
+
+struct ctrace_span_event *ctr_span_event_add(struct ctrace_span *span, char *name)
+{
+    return ctr_span_event_add_ts(span, name, 0);
+}
+
+int ctr_span_event_set_attribute_string(struct ctrace_span_event *event, char *key, char *value)
+{
+    return ctr_attributes_set_string(event->attr, key, value);
+}
+
+int ctr_span_event_set_attribute_bool(struct ctrace_span_event *event, char *key, int b)
+{
+    return ctr_attributes_set_bool(event->attr, key, b);
+}
+
+int ctr_span_event_set_attribute_int64(struct ctrace_span_event *event, char *key, int64_t value)
+{
+    return ctr_attributes_set_int64(event->attr, key, value);
+}
+
+int ctr_span_event_set_attribute_double(struct ctrace_span_event *event, char *key, double value)
+{
+    return ctr_attributes_set_double(event->attr, key, value);
+}
+
+int ctr_span_event_set_attribute_array(struct ctrace_span_event *event, char *key,
+                                       struct cfl_array *value)
+{
+    return ctr_attributes_set_array(event->attr, key, value);
+}
+
+int ctr_span_event_set_attribute_kvlist(struct ctrace_span_event *event, char *key,
+                                        struct cfl_kvlist *value)
+{
+
+    return ctr_attributes_set_kvlist(event->attr, key, value);
+}
+
+void ctr_span_event_set_dropped_attributes_count(struct ctrace_span_event *event, uint32_t count)
+{
+    event->dropped_attr_count = count;
+}
+
+void ctr_span_event_delete(struct ctrace_span_event *event)
+{
+    if (event->name) {
+        cfl_sds_destroy(event->name);
+    }
+
+    if (event->attr) {
+        ctr_attributes_destroy(event->attr);
+    }
+
+    cfl_list_del(&event->_head);
+    free(event);
+}
+
diff --git a/fluent-bit/lib/ctraces/src/ctr_utils.c b/fluent-bit/lib/ctraces/src/ctr_utils.c
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_utils.c
diff --git a/fluent-bit/lib/ctraces/src/ctr_version.c b/fluent-bit/lib/ctraces/src/ctr_version.c
new file mode 100644
index 000000000..923e6d89b
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctr_version.c
@@ -0,0 +1,26 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+
+char *ctr_version()
+{
+    return CTR_VERSION_STR;
+}
\ No newline at end of file
diff --git a/fluent-bit/lib/ctraces/src/ctraces.c b/fluent-bit/lib/ctraces/src/ctraces.c
new file mode 100644
index 000000000..d2258be5d
--- /dev/null
+++ b/fluent-bit/lib/ctraces/src/ctraces.c
@@ -0,0 +1,72 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+
+void ctr_opts_init(struct ctrace_opts *opts)
+{
+    memset(opts, '\0', sizeof(struct ctrace_opts));
+}
+
+void ctr_opts_set(struct ctrace_opts *opts, int value, char *val)
+{
+    /* unused */
+    (void) opts;
+    (void) value;
+    (void) val;
+}
+
+void ctr_opts_exit(struct ctrace_opts *opts)
+{
+    if (!opts) {
+        return;
+    }
+}
+
+/* Create a CTrace context */
+struct ctrace *ctr_create(struct ctrace_opts *opts)
+{
+    struct ctrace *ctx;
+
+    ctx = calloc(1, sizeof(struct ctrace));
+    if (!ctx) {
+        ctr_errno();
+        return NULL;
+    }
+    cfl_list_init(&ctx->resource_spans);
+    cfl_list_init(&ctx->span_list);
+
+    return ctx;
+}
+
+void ctr_destroy(struct ctrace *ctx)
+{
+    struct cfl_list *head;
+    struct cfl_list *tmp;
+    struct ctrace_resource_span *resource_span;
+
+    /* delete resources */
+    cfl_list_foreach_safe(head, tmp, &ctx->resource_spans) {
+        resource_span = cfl_list_entry(head, struct ctrace_resource_span, _head);
+        ctr_resource_span_destroy(resource_span);
+    }
+
+    free(ctx);
+}
+
diff --git a/fluent-bit/lib/ctraces/tests/CMakeLists.txt b/fluent-bit/lib/ctraces/tests/CMakeLists.txt
new file mode 100644
index 000000000..9f2841029
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/CMakeLists.txt
@@ -0,0 +1,33 @@
+set(UNIT_TESTS_FILES
+  decoding.c
+  basic.c
+  span.c
+  )
+
+set(CTR_TESTS_DATA_PATH "${CMAKE_CURRENT_SOURCE_DIR}/data")
+configure_file(
+  "${CMAKE_CURRENT_SOURCE_DIR}/ctr_tests_config.h.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/ctr_tests_config.h"
+  )
+
+# Prepare list of unit tests
+foreach(source_file ${UNIT_TESTS_FILES})
+  get_filename_component(source_file_we ${source_file} NAME_WE)
+  set(source_file_we ctr-test-${source_file_we})
+
+  add_executable(
+    ${source_file_we}
+    ${source_file}
+    )
+
+  target_link_libraries(${source_file_we} ctraces-static)
+
+if(NOT CTR_SYSTEM_WINDOWS)
+  target_link_libraries(${source_file_we} pthread)
+endif()
+
+  add_test(NAME ${source_file_we}
+    COMMAND ${CMAKE_BINARY_DIR}/tests/${source_file_we}
+    WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/tests)
+  set_tests_properties(${source_file_we} PROPERTIES LABELS "internal")
+endforeach()
diff --git a/fluent-bit/lib/ctraces/tests/basic.c b/fluent-bit/lib/ctraces/tests/basic.c
new file mode 100644
index 000000000..74e4c6bdc
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/basic.c
@@ -0,0 +1,59 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include "ctr_tests.h"
+
+#define OPTS_TRACE_ID  "4582829a12781087"
+
+void test_basic()
+{
+    struct ctrace *ctx;
+
+    printf("version => '%s'", ctr_version());
+
+    ctx = ctr_create(NULL);
+    TEST_CHECK(ctx != NULL);
+
+    ctr_destroy(ctx);
+}
+
+void test_options()
+{
+    struct ctrace *ctx;
+    struct ctrace_opts opts;
+
+    /* options */
+    ctr_opts_init(&opts);
+
+    /* create & destroy context */
+    ctx = ctr_create(&opts);
+
+    TEST_CHECK(ctx != NULL);
+    ctr_destroy(ctx);
+
+    /* exit options */
+    ctr_opts_exit(&opts);
+}
+
+TEST_LIST = {
+    {"basic", test_basic},
+    {"options", test_options},
+    { 0 }
+};
diff --git a/fluent-bit/lib/ctraces/tests/ctr_tests.h b/fluent-bit/lib/ctraces/tests/ctr_tests.h
new file mode 100644
index 000000000..57e7b29c3
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/ctr_tests.h
@@ -0,0 +1,26 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_TESTS_H
+#define CTR_TESTS_H
+
+#include "lib/acutest/acutest.h"
+//#include "tests/ctr_tests_config.h"
+
+#endif
diff --git a/fluent-bit/lib/ctraces/tests/ctr_tests_config.h.in b/fluent-bit/lib/ctraces/tests/ctr_tests_config.h.in
new file mode 100644
index 000000000..9b92dc3c9
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/ctr_tests_config.h.in
@@ -0,0 +1,25 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef CTR_TESTS_CONFIG_H
+#define CTR_TESTS_CONFIG_H
+
+#define CTR_TESTS_DATA_PATH "@CTR_TESTS_DATA_PATH@"
+
+#endif
diff --git a/fluent-bit/lib/ctraces/tests/decoding.c b/fluent-bit/lib/ctraces/tests/decoding.c
new file mode 100644
index 000000000..ab919b94a
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/decoding.c
@@ -0,0 +1,644 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CMetrics
+ *  ========
+ *  Copyright 2021 Eduardo Silva <eduardo@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#ifdef __GNUC__
+#define _GNU_SOURCE
+#endif
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_encode_msgpack.h>
+#include <ctraces/ctr_decode_msgpack.h>
+#include <ctraces/ctr_encode_text.h>
+#include "ctr_tests.h"
+
+static int generate_dummy_array_attribute_set(struct cfl_array **out_array, size_t current_depth, size_t max_depth);
+static int generate_dummy_kvlist_attribute_set(struct cfl_kvlist **out_kvlist, size_t current_depth, size_t max_depth);
+
+struct cfl_kvlist *get_or_create_external_metadata_kvlist(
+    struct cfl_kvlist *root, char *key)
+{
+    struct cfl_variant *entry_variant;
+    struct cfl_kvlist  *entry_kvlist;
+    int                 result;
+
+    entry_variant = cfl_kvlist_fetch(root, key);
+
+    if (entry_variant == NULL) {
+        entry_kvlist = cfl_kvlist_create();
+
+        if (entry_kvlist == NULL) {
+            return NULL;
+        }
+
+        result = cfl_kvlist_insert_kvlist(root,
+                                          key,
+                                          entry_kvlist);
+
+        if (result != 0) {
+            cfl_kvlist_destroy(entry_kvlist);
+
+            return NULL;
+        }
+    }
+    else {
+        entry_kvlist = entry_variant->data.as_kvlist;
+    }
+
+    return entry_kvlist;
+}
+
+static int generate_dummy_array_attribute_set(struct cfl_array **out_array, size_t current_depth, size_t max_depth)
+{
+    struct cfl_array  *inner_array;
+    int                result;
+    struct cfl_kvlist *kvlist;
+    struct cfl_array  *array;
+
+    if (*out_array == NULL) {
+        array = cfl_array_create(10);
+    }
+    else {
+        array = *out_array;
+    }
+
+    if (array == NULL) {
+        return -1;
+    }
+
+    cfl_array_append_string(array, "string value");
+    cfl_array_append_bytes(array, "\xFF\xEE\xFF\xEE\xCA\xFE", 6);
+    cfl_array_append_bool(array, CTR_TRUE);
+    cfl_array_append_int64(array, 303456);
+    cfl_array_append_double(array, 1.23456);
+
+    if (current_depth < max_depth) {
+        kvlist = NULL;
+
+        result = generate_dummy_kvlist_attribute_set(&kvlist, current_depth + 1, max_depth);
+
+        if (result != 0) {
+            return -2;
+        }
+
+        result = cfl_array_append_kvlist(array, kvlist);
+
+        if (result != 0) {
+            return -3;
+        }
+
+        inner_array = NULL;
+
+        result = generate_dummy_array_attribute_set(&inner_array, current_depth + 1, max_depth);
+
+        if (result != 0) {
+            return -4;
+        }
+
+        result = cfl_array_append_array(array, inner_array);
+
+        if (result != 0) {
+            return -5;
+        }
+    }
+
+    *out_array = array;
+
+    return 0;
+}
+
+static int generate_dummy_kvlist_attribute_set(struct cfl_kvlist **out_kvlist, size_t current_depth, size_t max_depth)
+{
+    struct cfl_kvlist *inner_kvlist;
+    int                result;
+    struct cfl_kvlist *kvlist;
+    struct cfl_array  *array;
+
+    if (*out_kvlist == NULL) {
+        kvlist = cfl_kvlist_create();
+    }
+    else {
+        kvlist = *out_kvlist;
+    }
+
+    if (kvlist == NULL) {
+        return -1;
+    }
+
+    result = cfl_kvlist_insert_string(kvlist, "string value", "test value 1");
+
+    if (result != 0) {
+        return -1;
+    }
+
+
+    result = cfl_kvlist_insert_int64(kvlist, "integer value", 789);
+
+    if (result != 0) {
+        return -2;
+    }
+
+    result = cfl_kvlist_insert_double(kvlist, "double value", 0.9825);
+
+    if (result != 0) {
+        return -3;
+    }
+
+    result = cfl_kvlist_insert_bool(kvlist, "bool value", 0);
+
+    if (result != 0) {
+        return -3;
+    }
+
+    result = cfl_kvlist_insert_bytes(kvlist, "bytes value", "\xFE\xEE\xFF\xEE\xCA\xFE", 6);
+
+    if (result != 0) {
+        return -3;
+    }
+
+    if (current_depth < max_depth) {
+        array = NULL;
+
+        result = generate_dummy_array_attribute_set(&array, current_depth + 1, max_depth);
+
+        if (result != 0) {
+            return -3;
+        }
+
+        result = cfl_kvlist_insert_array(kvlist, "array value", array);
+
+        if (result != 0) {
+            return -3;
+        }
+
+        inner_kvlist = NULL;
+
+        result = generate_dummy_kvlist_attribute_set(&inner_kvlist, current_depth + 1, max_depth);
+
+        if (result != 0) {
+            return -3;
+        }
+
+        result = cfl_kvlist_insert_kvlist(kvlist, "kvlist value", inner_kvlist);
+
+        if (result != 0) {
+            return -3;
+        }
+    }
+
+    *out_kvlist = kvlist;
+
+    return 0;
+}
+
+static int generate_sample_resource_attributes(struct ctrace_resource *resource)
+{
+    struct ctrace_attributes *attributes;
+    int                       result;
+
+    attributes = ctr_attributes_create();
+
+    if (attributes == NULL) {
+        return -1;
+    }
+
+    result = generate_dummy_kvlist_attribute_set(&attributes->kv, 0, 2);
+
+    if (result != 0) {
+        ctr_attributes_destroy(attributes);
+
+        return -2;
+    }
+
+    result = ctr_resource_set_attributes(resource, attributes);
+
+    if (result != 0) {
+        ctr_attributes_destroy(attributes);
+
+        return -3;
+    }
+
+    return 0;
+}
+
+static int generate_sample_link_attributes(struct ctrace_link *link)
+{
+    struct ctrace_attributes *attributes;
+    int                       result;
+
+    attributes = ctr_attributes_create();
+
+    if (attributes == NULL) {
+        return -1;
+    }
+
+    result = generate_dummy_kvlist_attribute_set(&attributes->kv, 0, 2);
+
+    if (result != 0) {
+        ctr_attributes_destroy(attributes);
+
+        return -2;
+    }
+
+    result = ctr_link_set_attributes(link, attributes);
+
+    if (result != 0) {
+        ctr_attributes_destroy(attributes);
+
+        return -3;
+    }
+
+    return 0;
+}
+
+int generate_sample_instrumentation_scope(struct ctrace_scope_span *scope_span)
+{
+    struct ctrace_instrumentation_scope *instrumentation_scope;
+    struct ctrace_attributes            *attributes;
+    int                                  result;
+
+    attributes = ctr_attributes_create();
+
+    if (attributes == NULL) {
+        return -1;
+    }
+
+    result = generate_dummy_kvlist_attribute_set(&attributes->kv, 0, 2);
+
+    if (result != 0) {
+        ctr_attributes_destroy(attributes);
+
+        return -2;
+    }
+
+    instrumentation_scope = ctr_instrumentation_scope_create("sample instrumentation scope",
+                                                             "0.0.1",
+                                                             123,
+                                                             attributes);
+
+    if (instrumentation_scope == NULL) {
+        ctr_attributes_destroy(attributes);
+
+        return -3;
+    }
+
+    ctr_scope_span_set_instrumentation_scope(scope_span, instrumentation_scope);
+
+    return 0;
+}
+
+
+
+static struct ctrace *generate_encoder_test_data()
+{
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_scope_span    *scope_span;
+    struct ctrace               *context;
+    int                          result;
+    struct ctrace_span_event    *event;
+    struct ctrace_span          *span;
+    struct ctrace_link          *link;
+
+    context = ctr_create(NULL);
+
+    if (context == NULL) {
+        return NULL;
+    }
+
+    resource_span = ctr_resource_span_create(context);
+
+    if (resource_span == NULL) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_resource_span_set_schema_url(resource_span, "http://resource_1.schema.url:9999/spec.json");
+    ctr_resource_set_dropped_attr_count(resource_span->resource, 123);
+
+    result = generate_sample_resource_attributes(resource_span->resource);
+
+    if (result != 0) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    scope_span = ctr_scope_span_create(resource_span);
+
+    if (scope_span == NULL) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_scope_span_set_schema_url(scope_span, "http://scope_span_1.schema.url:8888/spec.json");
+
+    result = generate_sample_instrumentation_scope(scope_span);
+
+    if (result != 0) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    span = ctr_span_create(context, scope_span, "sample span 1", NULL);
+
+    if (span == NULL) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_span_set_status(span, CTRACE_SPAN_STATUS_CODE_OK, "TEST STATE 1");
+    ctr_span_set_trace_id(span, "CTR_TRACE_000001", 16);
+    ctr_span_set_span_id(span, "SPAN_001", 8);
+    ctr_span_set_parent_span_id(span, "SPAN_801", 8);
+    ctr_span_kind_set(span, CTRACE_SPAN_INTERNAL);
+    ctr_span_start_ts(context, span, 1000000);
+    ctr_span_end_ts(context, span, 2000000);
+
+    result = generate_dummy_kvlist_attribute_set(&span->attr->kv, 0, 2);
+
+    if (result != 0) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_span_set_dropped_events_count(span, 555);
+
+    event = ctr_span_event_add_ts(span, "span_1_event_1", 0x7357);
+
+    if (event == NULL) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_span_event_set_dropped_attributes_count(event, 999);
+
+    result = generate_dummy_kvlist_attribute_set(&event->attr->kv, 0, 2);
+
+    if (result != 0) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    // ctr_span_event_set_attribute_string(event, "event_attribute_1", "TEST STRING attribute value");
+    // ctr_span_event_set_attribute_int(event,  "event_attribute_2", 987);
+    // ctr_span_event_set_attribute_double(event, "event_attribute_2", 9.21);
+    ctr_span_event_set_dropped_attributes_count(event, 888);
+
+    link = ctr_link_create(span,
+                           "CTR_TRACE_800000", 16,
+                           "SPAN_801", 8);
+
+    if (link == NULL) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    ctr_link_set_trace_state(link, "TEST STATE 2");
+    ctr_link_set_dropped_attr_count(link, 987);
+
+    result = generate_sample_link_attributes(link);
+
+    if (result != 0) {
+        ctr_destroy(context);
+
+        return NULL;
+    }
+
+    return context;
+}
+
+/*
+ * perform the following and then compare text buffers
+ *
+ * CMT +-> MSGPACK -> CMT -> TEXT
+ *     +-> TEXT                |
+ *          |                  |
+ *          |---> compare <----|
+ */
+
+static void msgpack_encode_decode_and_compare(struct ctrace *context)
+{
+    char          *validation_text_buffer;
+    char          *referece_text_buffer;
+    char          *msgpack_text_buffer;
+    size_t         msgpack_text_size;
+    struct ctrace *decoded_context;
+    size_t         offset;
+    int            result;
+
+    offset = 0;
+
+    referece_text_buffer = ctr_encode_text_create(context);
+    TEST_ASSERT(referece_text_buffer != NULL);
+
+    result = ctr_encode_msgpack_create(context, &msgpack_text_buffer, &msgpack_text_size);
+    TEST_ASSERT(result == 0);
+
+    result = ctr_decode_msgpack_create(&decoded_context, msgpack_text_buffer, msgpack_text_size, &offset);
+    TEST_ASSERT(result == 0);
+
+    validation_text_buffer = ctr_encode_text_create(context);
+    TEST_ASSERT(validation_text_buffer != NULL);
+
+    TEST_ASSERT(strcmp(referece_text_buffer, validation_text_buffer) == 0);
+
+    ctr_encode_msgpack_destroy(msgpack_text_buffer);
+    ctr_encode_text_destroy(validation_text_buffer);
+    ctr_encode_text_destroy(referece_text_buffer);
+
+    ctr_destroy(decoded_context);
+}
+
+void test_msgpack_to_cmt()
+{
+    struct ctrace *context;
+
+    context = generate_encoder_test_data();
+    TEST_ASSERT(context != NULL);
+
+    msgpack_encode_decode_and_compare(context);
+
+    ctr_destroy(context);
+}
+
+void test_simple_to_msgpack_and_back()
+{
+    struct ctrace *ctx;
+    struct ctrace_opts opts;
+    struct ctrace_span *span_root;
+    struct ctrace_span *span_child;
+    struct ctrace_span_event *event;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_resource *resource;
+    struct ctrace_scope_span *scope_span;
+    struct ctrace_instrumentation_scope *instrumentation_scope;
+    struct ctrace_link *link;
+    struct ctrace_id *span_id;
+    struct ctrace_id *trace_id;
+    struct cfl_array *array;
+    struct cfl_array *sub_array;
+    struct cfl_kvlist *kv;
+
+    /*
+     * create an options context: this is used to initialize a CTrace context only,
+     * it's not mandatory and you can pass a NULL instead on context creation.
+     *
+     * note: not used.
+     */
+    ctr_opts_init(&opts);
+
+    /* ctrace context */
+    ctx = ctr_create(&opts);
+    TEST_ASSERT(ctx != NULL);
+
+    /* resource span */
+    resource_span = ctr_resource_span_create(ctx);
+    ctr_resource_span_set_schema_url(resource_span, "https://ctraces/resource_span_schema_url");
+
+    /* create a 'resource' for the 'resource span' in question */
+    resource = ctr_resource_span_get_resource(resource_span);
+    ctr_resource_set_dropped_attr_count(resource, 5);
+
+    /* scope span */
+    scope_span = ctr_scope_span_create(resource_span);
+    ctr_scope_span_set_schema_url(scope_span, "https://ctraces/scope_span_schema_url");
+
+    /* create an optional instrumentation scope */
+    instrumentation_scope = ctr_instrumentation_scope_create("ctrace", "a.b.c", 3, NULL);
+    TEST_ASSERT(instrumentation_scope != NULL);
+
+    ctr_scope_span_set_instrumentation_scope(scope_span, instrumentation_scope);
+
+    /* generate a random trace_id */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+    TEST_ASSERT(trace_id != NULL);
+
+    /* generate a random ID for the new span */
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    TEST_ASSERT(span_id != NULL);
+
+    /* Create a root span */
+    span_root = ctr_span_create(ctx, scope_span, "main", NULL);
+    TEST_ASSERT(span_root != NULL);
+
+    /* assign the random ID */
+    ctr_span_set_span_id_with_cid(span_root, span_id);
+
+    /* set random trace_id */
+    ctr_span_set_trace_id_with_cid(span_root, trace_id);
+
+    /* add some attributes to the span */
+    ctr_span_set_attribute_string(span_root, "agent", "Fluent Bit");
+    ctr_span_set_attribute_int64(span_root, "year", 2022);
+    ctr_span_set_attribute_bool(span_root, "open_source", CTR_TRUE);
+    ctr_span_set_attribute_double(span_root, "temperature", 25.5);
+
+    /* pack an array: create an array context by using the CFL api */
+    array = cfl_array_create(4);
+    TEST_ASSERT(array != NULL);
+    cfl_array_append_string(array, "first");
+    cfl_array_append_double(array, 2.0);
+    cfl_array_append_bool(array, CFL_FALSE);
+
+    sub_array = cfl_array_create(3);
+    TEST_ASSERT(sub_array != NULL);
+    cfl_array_append_double(sub_array, 3.1);
+    cfl_array_append_double(sub_array, 5.2);
+    cfl_array_append_double(sub_array, 6.3);
+    cfl_array_append_array(array, sub_array);
+
+    /* add array to the attribute list */
+    ctr_span_set_attribute_array(span_root, "my_array", array);
+
+    /* event: add one event and set attributes to it */
+    event = ctr_span_event_add(span_root, "connect to remote server");
+    TEST_ASSERT(event != NULL);
+
+    ctr_span_event_set_attribute_string(event, "syscall 1", "open()");
+    ctr_span_event_set_attribute_string(event, "syscall 2", "connect()");
+    ctr_span_event_set_attribute_string(event, "syscall 3", "write()");
+
+    /* add a key/value pair list */
+    kv = cfl_kvlist_create(1);
+    TEST_ASSERT(kv != NULL);
+    cfl_kvlist_insert_string(kv, "language", "c");
+
+    ctr_span_set_attribute_kvlist(span_root, "my-list", kv);
+
+    /* create a child span */
+    span_child = ctr_span_create(ctx, scope_span, "do-work", span_root);
+    TEST_ASSERT(span_child != NULL);
+
+    /* set trace_id */
+    ctr_span_set_trace_id_with_cid(span_child, trace_id);
+
+    /* use span_root ID as parent_span_id */
+    ctr_span_set_parent_span_id_with_cid(span_child, span_id);
+
+    /* delete old span id and generate a new one */
+    ctr_id_destroy(span_id);
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    TEST_ASSERT(span_id != NULL);
+    ctr_span_set_span_id_with_cid(span_child, span_id);
+
+    /* destroy the IDs since is not longer needed */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    /* change span kind to client */
+    ctr_span_kind_set(span_child, CTRACE_SPAN_CLIENT);
+
+    /* create a Link (no valid IDs of course) */
+    trace_id = ctr_id_create_random(CTR_ID_OTEL_TRACE_SIZE);
+    TEST_ASSERT(trace_id != NULL);
+
+    span_id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    TEST_ASSERT(span_id != NULL);
+
+    link = ctr_link_create_with_cid(span_child, trace_id, span_id);
+    TEST_ASSERT(link != NULL);
+
+    ctr_link_set_trace_state(link, "aaabbbccc");
+    ctr_link_set_dropped_attr_count(link, 2);
+
+    /* delete IDs */
+    ctr_id_destroy(span_id);
+    ctr_id_destroy(trace_id);
+
+    msgpack_encode_decode_and_compare(ctx);
+
+    /* destroy the context */
+    ctr_destroy(ctx);
+
+    /* exit options (it release resources allocated) */
+    ctr_opts_exit(&opts);
+}
+
+
+TEST_LIST = {
+    {"cmt_simple_to_msgpack_and_back", test_simple_to_msgpack_and_back},
+    {"cmt_msgpack",                    test_msgpack_to_cmt},
+    { 0 }
+};
diff --git a/fluent-bit/lib/ctraces/tests/lib/acutest/acutest.h b/fluent-bit/lib/ctraces/tests/lib/acutest/acutest.h
new file mode 100644
index 000000000..1d13044f0
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/lib/acutest/acutest.h
@@ -0,0 +1,1794 @@
+/*
+ * Acutest -- Another C/C++ Unit Test facility
+ * <https://github.com/mity/acutest>
+ *
+ * Copyright 2013-2020 Martin Mitas
+ * Copyright 2019 Garrett D'Amore
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef ACUTEST_H
+#define ACUTEST_H
+
+
+/************************
+ *** Public interface ***
+ ************************/
+
+/* By default, "acutest.h" provides the main program entry point (function
+ * main()). However, if the test suite is composed of multiple source files
+ * which include "acutest.h", then this causes a problem of multiple main()
+ * definitions. To avoid this problem, #define macro TEST_NO_MAIN in all
+ * compilation units but one.
+ */
+
+/* Macro to specify list of unit tests in the suite.
+ * The unit test implementation MUST provide list of unit tests it implements
+ * with this macro:
+ *
+ *   TEST_LIST = {
+ *       { "test1_name", test1_func_ptr },
+ *       { "test2_name", test2_func_ptr },
+ *       ...
+ *       { NULL, NULL }     // zeroed record marking the end of the list
+ *   };
+ *
+ * The list specifies names of each test (must be unique) and pointer to
+ * a function implementing it. The function does not take any arguments
+ * and has no return values, i.e. every test function has to be compatible
+ * with this prototype:
+ *
+ *   void test_func(void);
+ *
+ * Note the list has to be ended with a zeroed record.
+ */
+#define TEST_LIST               const struct acutest_test_ acutest_list_[]
+
+
+/* Macros for testing whether an unit test succeeds or fails. These macros
+ * can be used arbitrarily in functions implementing the unit tests.
+ *
+ * If any condition fails throughout execution of a test, the test fails.
+ *
+ * TEST_CHECK takes only one argument (the condition), TEST_CHECK_ allows
+ * also to specify an error message to print out if the condition fails.
+ * (It expects printf-like format string and its parameters). The macros
+ * return non-zero (condition passes) or 0 (condition fails).
+ *
+ * That can be useful when more conditions should be checked only if some
+ * preceding condition passes, as illustrated in this code snippet:
+ *
+ *   SomeStruct* ptr = allocate_some_struct();
+ *   if(TEST_CHECK(ptr != NULL)) {
+ *       TEST_CHECK(ptr->member1 < 100);
+ *       TEST_CHECK(ptr->member2 > 200);
+ *   }
+ */
+#define TEST_CHECK_(cond,...)   acutest_check_((cond), __FILE__, __LINE__, __VA_ARGS__)
+#define TEST_CHECK(cond)        acutest_check_((cond), __FILE__, __LINE__, "%s", #cond)
+
+
+/* These macros are the same as TEST_CHECK_ and TEST_CHECK except that if the
+ * condition fails, the currently executed unit test is immediately aborted.
+ *
+ * That is done either by calling abort() if the unit test is executed as a
+ * child process; or via longjmp() if the unit test is executed within the
+ * main Acutest process.
+ *
+ * As a side effect of such abortion, your unit tests may cause memory leaks,
+ * unflushed file descriptors, and other phenomena caused by the abortion.
+ *
+ * Therefore you should not use these as a general replacement for TEST_CHECK.
+ * Use it with some caution, especially if your test causes some other side
+ * effects to the outside world (e.g. communicating with some server, inserting
+ * into a database etc.).
+ */
+#define TEST_ASSERT_(cond,...)                                                 \
+    do {                                                                       \
+        if(!acutest_check_((cond), __FILE__, __LINE__, __VA_ARGS__))           \
+            acutest_abort_();                                                  \
+    } while(0)
+#define TEST_ASSERT(cond)                                                      \
+    do {                                                                       \
+        if(!acutest_check_((cond), __FILE__, __LINE__, "%s", #cond))           \
+            acutest_abort_();                                                  \
+    } while(0)
+
+
+#ifdef __cplusplus
+/* Macros to verify that the code (the 1st argument) throws exception of given
+ * type (the 2nd argument). (Note these macros are only available in C++.)
+ *
+ * TEST_EXCEPTION_ is like TEST_EXCEPTION but accepts custom printf-like
+ * message.
+ *
+ * For example:
+ *
+ *   TEST_EXCEPTION(function_that_throw(), ExpectedExceptionType);
+ *
+ * If the function_that_throw() throws ExpectedExceptionType, the check passes.
+ * If the function throws anything incompatible with ExpectedExceptionType
+ * (or if it does not thrown an exception at all), the check fails.
+ */
+#define TEST_EXCEPTION(code, exctype)                                          \
+    do {                                                                       \
+        bool exc_ok_ = false;                                                  \
+        const char *msg_ = NULL;                                               \
+        try {                                                                  \
+            code;                                                              \
+            msg_ = "No exception thrown.";                                     \
+        } catch(exctype const&) {                                              \
+            exc_ok_= true;                                                     \
+        } catch(...) {                                                         \
+            msg_ = "Unexpected exception thrown.";                             \
+        }                                                                      \
+        acutest_check_(exc_ok_, __FILE__, __LINE__, #code " throws " #exctype);\
+        if(msg_ != NULL)                                                       \
+            acutest_message_("%s", msg_);                                      \
+    } while(0)
+#define TEST_EXCEPTION_(code, exctype, ...)                                    \
+    do {                                                                       \
+        bool exc_ok_ = false;                                                  \
+        const char *msg_ = NULL;                                               \
+        try {                                                                  \
+            code;                                                              \
+            msg_ = "No exception thrown.";                                     \
+        } catch(exctype const&) {                                              \
+            exc_ok_= true;                                                     \
+        } catch(...) {                                                         \
+            msg_ = "Unexpected exception thrown.";                             \
+        }                                                                      \
+        acutest_check_(exc_ok_, __FILE__, __LINE__, __VA_ARGS__);              \
+        if(msg_ != NULL)                                                       \
+            acutest_message_("%s", msg_);                                      \
+    } while(0)
+#endif  /* #ifdef __cplusplus */
+
+
+/* Sometimes it is useful to split execution of more complex unit tests to some
+ * smaller parts and associate those parts with some names.
+ *
+ * This is especially handy if the given unit test is implemented as a loop
+ * over some vector of multiple testing inputs. Using these macros allow to use
+ * sort of subtitle for each iteration of the loop (e.g. outputting the input
+ * itself or a name associated to it), so that if any TEST_CHECK condition
+ * fails in the loop, it can be easily seen which iteration triggers the
+ * failure, without the need to manually output the iteration-specific data in
+ * every single TEST_CHECK inside the loop body.
+ *
+ * TEST_CASE allows to specify only single string as the name of the case,
+ * TEST_CASE_ provides all the power of printf-like string formatting.
+ *
+ * Note that the test cases cannot be nested. Starting a new test case ends
+ * implicitly the previous one. To end the test case explicitly (e.g. to end
+ * the last test case after exiting the loop), you may use TEST_CASE(NULL).
+ */
+#define TEST_CASE_(...)         acutest_case_(__VA_ARGS__)
+#define TEST_CASE(name)         acutest_case_("%s", name)
+
+
+/* Maximal output per TEST_CASE call. Longer messages are cut.
+ * You may define another limit prior including "acutest.h"
+ */
+#ifndef TEST_CASE_MAXSIZE
+    #define TEST_CASE_MAXSIZE    64
+#endif
+
+
+/* printf-like macro for outputting an extra information about a failure.
+ *
+ * Intended use is to output some computed output versus the expected value,
+ * e.g. like this:
+ *
+ *   if(!TEST_CHECK(produced == expected)) {
+ *       TEST_MSG("Expected: %d", expected);
+ *       TEST_MSG("Produced: %d", produced);
+ *   }
+ *
+ * Note the message is only written down if the most recent use of any checking
+ * macro (like e.g. TEST_CHECK or TEST_EXCEPTION) in the current test failed.
+ * This means the above is equivalent to just this:
+ *
+ *   TEST_CHECK(produced == expected);
+ *   TEST_MSG("Expected: %d", expected);
+ *   TEST_MSG("Produced: %d", produced);
+ *
+ * The macro can deal with multi-line output fairly well. It also automatically
+ * adds a final new-line if there is none present.
+ */
+#define TEST_MSG(...)           acutest_message_(__VA_ARGS__)
+
+
+/* Maximal output per TEST_MSG call. Longer messages are cut.
+ * You may define another limit prior including "acutest.h"
+ */
+#ifndef TEST_MSG_MAXSIZE
+    #define TEST_MSG_MAXSIZE    1024
+#endif
+
+
+/* Macro for dumping a block of memory.
+ *
+ * Its intended use is very similar to what TEST_MSG is for, but instead of
+ * generating any printf-like message, this is for dumping raw block of a
+ * memory in a hexadecimal form:
+ *
+ *   TEST_CHECK(size_produced == size_expected &&
+ *              memcmp(addr_produced, addr_expected, size_produced) == 0);
+ *   TEST_DUMP("Expected:", addr_expected, size_expected);
+ *   TEST_DUMP("Produced:", addr_produced, size_produced);
+ */
+#define TEST_DUMP(title, addr, size)    acutest_dump_(title, addr, size)
+
+/* Maximal output per TEST_DUMP call (in bytes to dump). Longer blocks are cut.
+ * You may define another limit prior including "acutest.h"
+ */
+#ifndef TEST_DUMP_MAXSIZE
+    #define TEST_DUMP_MAXSIZE   1024
+#endif
+
+
+/* Common test initialiation/clean-up
+ *
+ * In some test suites, it may be needed to perform some sort of the same
+ * initialization and/or clean-up in all the tests.
+ *
+ * Such test suites may use macros TEST_INIT and/or TEST_FINI prior including
+ * this header. The expansion of the macro is then used as a body of helper
+ * function called just before executing every single (TEST_INIT) or just after
+ * it ends (TEST_FINI).
+ *
+ * Examples of various ways how to use the macro TEST_INIT:
+ *
+ *   #define TEST_INIT      my_init_func();
+ *   #define TEST_INIT      my_init_func()      // Works even without the semicolon
+ *   #define TEST_INIT      setlocale(LC_ALL, NULL);
+ *   #define TEST_INIT      { setlocale(LC_ALL, NULL); my_init_func(); }
+ *
+ * TEST_FINI is to be used in the same way.
+ */
+
+
+/**********************
+ *** Implementation ***
+ **********************/
+
+/* The unit test files should not rely on anything below. */
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+
+#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__)
+    #define ACUTEST_UNIX_       1
+    #include <errno.h>
+    #include <libgen.h>
+    #include <unistd.h>
+    #include <sys/types.h>
+    #include <sys/wait.h>
+    #include <signal.h>
+    #include <time.h>
+
+    #if defined CLOCK_PROCESS_CPUTIME_ID  &&  defined CLOCK_MONOTONIC
+        #define ACUTEST_HAS_POSIX_TIMER_    1
+    #endif
+#endif
+
+#if defined(_gnu_linux_) || defined(__linux__)
+    #define ACUTEST_LINUX_      1
+    #include <fcntl.h>
+    #include <sys/stat.h>
+#endif
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)
+    #define ACUTEST_WIN_        1
+    #include <windows.h>
+    #include <io.h>
+#endif
+
+#ifdef __cplusplus
+    #include <exception>
+#endif
+
+#ifdef __has_include
+    #if __has_include(<valgrind.h>)
+        #include <valgrind.h>
+    #endif
+#endif
+
+/* Enable the use of the non-standard keyword __attribute__ to silence warnings under some compilers */
+#if defined(__GNUC__) || defined(__clang__)
+    #define ACUTEST_ATTRIBUTE_(attr)    __attribute__((attr))
+#else
+    #define ACUTEST_ATTRIBUTE_(attr)
+#endif
+
+/* Note our global private identifiers end with '_' to mitigate risk of clash
+ * with the unit tests implementation. */
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+#ifdef _MSC_VER
+    /* In the multi-platform code like ours, we cannot use the non-standard
+     * "safe" functions from Microsoft C lib like e.g. sprintf_s() instead of
+     * standard sprintf(). Hence, lets disable the warning C4996. */
+    #pragma warning(push)
+    #pragma warning(disable: 4996)
+#endif
+
+
+struct acutest_test_ {
+    const char* name;
+    void (*func)(void);
+};
+
+struct acutest_test_data_ {
+    unsigned char flags;
+    double duration;
+};
+
+enum {
+    ACUTEST_FLAG_RUN_ = 1 << 0,
+    ACUTEST_FLAG_SUCCESS_ = 1 << 1,
+    ACUTEST_FLAG_FAILURE_ = 1 << 2,
+};
+
+extern const struct acutest_test_ acutest_list_[];
+
+int acutest_check_(int cond, const char* file, int line, const char* fmt, ...);
+void acutest_case_(const char* fmt, ...);
+void acutest_message_(const char* fmt, ...);
+void acutest_dump_(const char* title, const void* addr, size_t size);
+void acutest_abort_(void) ACUTEST_ATTRIBUTE_(noreturn);
+
+
+#ifndef TEST_NO_MAIN
+
+static char* acutest_argv0_ = NULL;
+static size_t acutest_list_size_ = 0;
+static struct acutest_test_data_* acutest_test_data_ = NULL;
+static size_t acutest_count_ = 0;
+static int acutest_no_exec_ = -1;
+static int acutest_no_summary_ = 0;
+static int acutest_tap_ = 0;
+static int acutest_skip_mode_ = 0;
+static int acutest_worker_ = 0;
+static int acutest_worker_index_ = 0;
+static int acutest_cond_failed_ = 0;
+static int acutest_was_aborted_ = 0;
+static FILE *acutest_xml_output_ = NULL;
+
+static int acutest_stat_failed_units_ = 0;
+static int acutest_stat_run_units_ = 0;
+
+static const struct acutest_test_* acutest_current_test_ = NULL;
+static int acutest_current_index_ = 0;
+static char acutest_case_name_[TEST_CASE_MAXSIZE] = "";
+static int acutest_test_already_logged_ = 0;
+static int acutest_case_already_logged_ = 0;
+static int acutest_verbose_level_ = 2;
+static int acutest_test_failures_ = 0;
+static int acutest_colorize_ = 0;
+static int acutest_timer_ = 0;
+
+static int acutest_abort_has_jmp_buf_ = 0;
+static jmp_buf acutest_abort_jmp_buf_;
+
+
+static void
+acutest_cleanup_(void)
+{
+    free((void*) acutest_test_data_);
+}
+
+static void ACUTEST_ATTRIBUTE_(noreturn)
+acutest_exit_(int exit_code)
+{
+    acutest_cleanup_();
+    exit(exit_code);
+}
+
+#if defined ACUTEST_WIN_
+    typedef LARGE_INTEGER acutest_timer_type_;
+    static LARGE_INTEGER acutest_timer_freq_;
+    static acutest_timer_type_ acutest_timer_start_;
+    static acutest_timer_type_ acutest_timer_end_;
+
+    static void
+    acutest_timer_init_(void)
+    {
+        QueryPerformanceFrequency(&acutest_timer_freq_);
+    }
+
+    static void
+    acutest_timer_get_time_(LARGE_INTEGER* ts)
+    {
+        QueryPerformanceCounter(ts);
+    }
+
+    static double
+    acutest_timer_diff_(LARGE_INTEGER start, LARGE_INTEGER end)
+    {
+        double duration = (double)(end.QuadPart - start.QuadPart);
+        duration /= (double)acutest_timer_freq_.QuadPart;
+        return duration;
+    }
+
+    static void
+    acutest_timer_print_diff_(void)
+    {
+        printf("%.6lf secs", acutest_timer_diff_(acutest_timer_start_, acutest_timer_end_));
+    }
+#elif defined ACUTEST_HAS_POSIX_TIMER_
+    static clockid_t acutest_timer_id_;
+    typedef struct timespec acutest_timer_type_;
+    static acutest_timer_type_ acutest_timer_start_;
+    static acutest_timer_type_ acutest_timer_end_;
+
+    static void
+    acutest_timer_init_(void)
+    {
+        if(acutest_timer_ == 1)
+            acutest_timer_id_ = CLOCK_MONOTONIC;
+        else if(acutest_timer_ == 2)
+            acutest_timer_id_ = CLOCK_PROCESS_CPUTIME_ID;
+    }
+
+    static void
+    acutest_timer_get_time_(struct timespec* ts)
+    {
+        clock_gettime(acutest_timer_id_, ts);
+    }
+
+    static double
+    acutest_timer_diff_(struct timespec start, struct timespec end)
+    {
+        double endns;
+        double startns;
+
+        endns = end.tv_sec;
+        endns *= 1e9;
+        endns += end.tv_nsec;
+
+        startns = start.tv_sec;
+        startns *= 1e9;
+        startns += start.tv_nsec;
+
+        return ((endns - startns)/ 1e9);
+    }
+
+    static void
+    acutest_timer_print_diff_(void)
+    {
+        printf("%.6lf secs",
+            acutest_timer_diff_(acutest_timer_start_, acutest_timer_end_));
+    }
+#else
+    typedef int acutest_timer_type_;
+    static acutest_timer_type_ acutest_timer_start_;
+    static acutest_timer_type_ acutest_timer_end_;
+
+    void
+    acutest_timer_init_(void)
+    {}
+
+    static void
+    acutest_timer_get_time_(int* ts)
+    {
+        (void) ts;
+    }
+
+    static double
+    acutest_timer_diff_(int start, int end)
+    {
+        (void) start;
+        (void) end;
+        return 0.0;
+    }
+
+    static void
+    acutest_timer_print_diff_(void)
+    {}
+#endif
+
+#define ACUTEST_COLOR_DEFAULT_              0
+#define ACUTEST_COLOR_GREEN_                1
+#define ACUTEST_COLOR_RED_                  2
+#define ACUTEST_COLOR_DEFAULT_INTENSIVE_    3
+#define ACUTEST_COLOR_GREEN_INTENSIVE_      4
+#define ACUTEST_COLOR_RED_INTENSIVE_        5
+
+static int ACUTEST_ATTRIBUTE_(format (printf, 2, 3))
+acutest_colored_printf_(int color, const char* fmt, ...)
+{
+    va_list args;
+    char buffer[256];
+    int n;
+
+    va_start(args, fmt);
+    vsnprintf(buffer, sizeof(buffer), fmt, args);
+    va_end(args);
+    buffer[sizeof(buffer)-1] = '\0';
+
+    if(!acutest_colorize_) {
+        return printf("%s", buffer);
+    }
+
+#if defined ACUTEST_UNIX_
+    {
+        const char* col_str;
+        switch(color) {
+            case ACUTEST_COLOR_GREEN_:              col_str = "\033[0;32m"; break;
+            case ACUTEST_COLOR_RED_:                col_str = "\033[0;31m"; break;
+            case ACUTEST_COLOR_GREEN_INTENSIVE_:    col_str = "\033[1;32m"; break;
+            case ACUTEST_COLOR_RED_INTENSIVE_:      col_str = "\033[1;31m"; break;
+            case ACUTEST_COLOR_DEFAULT_INTENSIVE_:  col_str = "\033[1m"; break;
+            default:                                col_str = "\033[0m"; break;
+        }
+        printf("%s", col_str);
+        n = printf("%s", buffer);
+        printf("\033[0m");
+        return n;
+    }
+#elif defined ACUTEST_WIN_
+    {
+        HANDLE h;
+        CONSOLE_SCREEN_BUFFER_INFO info;
+        WORD attr;
+
+        h = GetStdHandle(STD_OUTPUT_HANDLE);
+        GetConsoleScreenBufferInfo(h, &info);
+
+        switch(color) {
+            case ACUTEST_COLOR_GREEN_:              attr = FOREGROUND_GREEN; break;
+            case ACUTEST_COLOR_RED_:                attr = FOREGROUND_RED; break;
+            case ACUTEST_COLOR_GREEN_INTENSIVE_:    attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
+            case ACUTEST_COLOR_RED_INTENSIVE_:      attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+            case ACUTEST_COLOR_DEFAULT_INTENSIVE_:  attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+            default:                                attr = 0; break;
+        }
+        if(attr != 0)
+            SetConsoleTextAttribute(h, attr);
+        n = printf("%s", buffer);
+        SetConsoleTextAttribute(h, info.wAttributes);
+        return n;
+    }
+#else
+    n = printf("%s", buffer);
+    return n;
+#endif
+}
+
+static void
+acutest_begin_test_line_(const struct acutest_test_* test)
+{
+    if(!acutest_tap_) {
+        if(acutest_verbose_level_ >= 3) {
+            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s:\n", test->name);
+            acutest_test_already_logged_++;
+        } else if(acutest_verbose_level_ >= 1) {
+            int n;
+            char spaces[48];
+
+            n = acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s... ", test->name);
+            memset(spaces, ' ', sizeof(spaces));
+            if(n < (int) sizeof(spaces))
+                printf("%.*s", (int) sizeof(spaces) - n, spaces);
+        } else {
+            acutest_test_already_logged_ = 1;
+        }
+    }
+}
+
+static void
+acutest_finish_test_line_(int result)
+{
+    if(acutest_tap_) {
+        const char* str = (result == 0) ? "ok" : "not ok";
+
+        printf("%s %d - %s\n", str, acutest_current_index_ + 1, acutest_current_test_->name);
+
+        if(result == 0  &&  acutest_timer_) {
+            printf("# Duration: ");
+            acutest_timer_print_diff_();
+            printf("\n");
+        }
+    } else {
+        int color = (result == 0) ? ACUTEST_COLOR_GREEN_INTENSIVE_ : ACUTEST_COLOR_RED_INTENSIVE_;
+        const char* str = (result == 0) ? "OK" : "FAILED";
+        printf("[ ");
+        acutest_colored_printf_(color, "%s", str);
+        printf(" ]");
+
+        if(result == 0  &&  acutest_timer_) {
+            printf("  ");
+            acutest_timer_print_diff_();
+        }
+
+        printf("\n");
+    }
+}
+
+static void
+acutest_line_indent_(int level)
+{
+    static const char spaces[] = "                ";
+    int n = level * 2;
+
+    if(acutest_tap_  &&  n > 0) {
+        n--;
+        printf("#");
+    }
+
+    while(n > 16) {
+        printf("%s", spaces);
+        n -= 16;
+    }
+    printf("%.*s", n, spaces);
+}
+
+int ACUTEST_ATTRIBUTE_(format (printf, 4, 5))
+acutest_check_(int cond, const char* file, int line, const char* fmt, ...)
+{
+    const char *result_str;
+    int result_color;
+    int verbose_level;
+
+    if(cond) {
+        result_str = "ok";
+        result_color = ACUTEST_COLOR_GREEN_;
+        verbose_level = 3;
+    } else {
+        if(!acutest_test_already_logged_  &&  acutest_current_test_ != NULL)
+            acutest_finish_test_line_(-1);
+
+        result_str = "failed";
+        result_color = ACUTEST_COLOR_RED_;
+        verbose_level = 2;
+        acutest_test_failures_++;
+        acutest_test_already_logged_++;
+    }
+
+    if(acutest_verbose_level_ >= verbose_level) {
+        va_list args;
+
+        if(!acutest_case_already_logged_  &&  acutest_case_name_[0]) {
+            acutest_line_indent_(1);
+            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
+            acutest_test_already_logged_++;
+            acutest_case_already_logged_++;
+        }
+
+        acutest_line_indent_(acutest_case_name_[0] ? 2 : 1);
+        if(file != NULL) {
+#ifdef ACUTEST_WIN_
+            const char* lastsep1 = strrchr(file, '\\');
+            const char* lastsep2 = strrchr(file, '/');
+            if(lastsep1 == NULL)
+                lastsep1 = file-1;
+            if(lastsep2 == NULL)
+                lastsep2 = file-1;
+            file = (lastsep1 > lastsep2 ? lastsep1 : lastsep2) + 1;
+#else
+            const char* lastsep = strrchr(file, '/');
+            if(lastsep != NULL)
+                file = lastsep+1;
+#endif
+            printf("%s:%d: Check ", file, line);
+        }
+
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+
+        printf("... ");
+        acutest_colored_printf_(result_color, "%s", result_str);
+        printf("\n");
+        acutest_test_already_logged_++;
+    }
+
+    acutest_cond_failed_ = (cond == 0);
+    return !acutest_cond_failed_;
+}
+
+void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
+acutest_case_(const char* fmt, ...)
+{
+    va_list args;
+
+    if(acutest_verbose_level_ < 2)
+        return;
+
+    if(acutest_case_name_[0]) {
+        acutest_case_already_logged_ = 0;
+        acutest_case_name_[0] = '\0';
+    }
+
+    if(fmt == NULL)
+        return;
+
+    va_start(args, fmt);
+    vsnprintf(acutest_case_name_, sizeof(acutest_case_name_) - 1, fmt, args);
+    va_end(args);
+    acutest_case_name_[sizeof(acutest_case_name_) - 1] = '\0';
+
+    if(acutest_verbose_level_ >= 3) {
+        acutest_line_indent_(1);
+        acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
+        acutest_test_already_logged_++;
+        acutest_case_already_logged_++;
+    }
+}
+
+void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
+acutest_message_(const char* fmt, ...)
+{
+    char buffer[TEST_MSG_MAXSIZE];
+    char* line_beg;
+    char* line_end;
+    va_list args;
+
+    if(acutest_verbose_level_ < 2)
+        return;
+
+    /* We allow extra message only when something is already wrong in the
+     * current test. */
+    if(acutest_current_test_ == NULL  ||  !acutest_cond_failed_)
+        return;
+
+    va_start(args, fmt);
+    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
+    va_end(args);
+    buffer[TEST_MSG_MAXSIZE-1] = '\0';
+
+    line_beg = buffer;
+    while(1) {
+        line_end = strchr(line_beg, '\n');
+        if(line_end == NULL)
+            break;
+        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
+        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
+        line_beg = line_end + 1;
+    }
+    if(line_beg[0] != '\0') {
+        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
+        printf("%s\n", line_beg);
+    }
+}
+
+void
+acutest_dump_(const char* title, const void* addr, size_t size)
+{
+    static const size_t BYTES_PER_LINE = 16;
+    size_t line_beg;
+    size_t truncate = 0;
+
+    if(acutest_verbose_level_ < 2)
+        return;
+
+    /* We allow extra message only when something is already wrong in the
+     * current test. */
+    if(acutest_current_test_ == NULL  ||  !acutest_cond_failed_)
+        return;
+
+    if(size > TEST_DUMP_MAXSIZE) {
+        truncate = size - TEST_DUMP_MAXSIZE;
+        size = TEST_DUMP_MAXSIZE;
+    }
+
+    acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
+    printf((title[strlen(title)-1] == ':') ? "%s\n" : "%s:\n", title);
+
+    for(line_beg = 0; line_beg < size; line_beg += BYTES_PER_LINE) {
+        size_t line_end = line_beg + BYTES_PER_LINE;
+        size_t off;
+
+        acutest_line_indent_(acutest_case_name_[0] ? 4 : 3);
+        printf("%08lx: ", (unsigned long)line_beg);
+        for(off = line_beg; off < line_end; off++) {
+            if(off < size)
+                printf(" %02x", ((const unsigned char*)addr)[off]);
+            else
+                printf("   ");
+        }
+
+        printf("  ");
+        for(off = line_beg; off < line_end; off++) {
+            unsigned char byte = ((const unsigned char*)addr)[off];
+            if(off < size)
+                printf("%c", (iscntrl(byte) ? '.' : byte));
+            else
+                break;
+        }
+
+        printf("\n");
+    }
+
+    if(truncate > 0) {
+        acutest_line_indent_(acutest_case_name_[0] ? 4 : 3);
+        printf("           ... (and more %u bytes)\n", (unsigned) truncate);
+    }
+}
+
+/* This is called just before each test */
+static void
+acutest_init_(const char *test_name)
+{
+#ifdef TEST_INIT
+    TEST_INIT
+    ; /* Allow for a single unterminated function call */
+#endif
+
+    /* Suppress any warnings about unused variable. */
+    (void) test_name;
+}
+
+/* This is called after each test */
+static void
+acutest_fini_(const char *test_name)
+{
+#ifdef TEST_FINI
+    TEST_FINI
+    ; /* Allow for a single unterminated function call */
+#endif
+
+    /* Suppress any warnings about unused variable. */
+    (void) test_name;
+}
+
+void
+acutest_abort_(void)
+{
+    if(acutest_abort_has_jmp_buf_) {
+        longjmp(acutest_abort_jmp_buf_, 1);
+    } else {
+        if(acutest_current_test_ != NULL)
+            acutest_fini_(acutest_current_test_->name);
+        abort();
+    }
+}
+
+static void
+acutest_list_names_(void)
+{
+    const struct acutest_test_* test;
+
+    printf("Unit tests:\n");
+    for(test = &acutest_list_[0]; test->func != NULL; test++)
+        printf("  %s\n", test->name);
+}
+
+static void
+acutest_remember_(int i)
+{
+    if(acutest_test_data_[i].flags & ACUTEST_FLAG_RUN_)
+        return;
+
+    acutest_test_data_[i].flags |= ACUTEST_FLAG_RUN_;
+    acutest_count_++;
+}
+
+static void
+acutest_set_success_(int i, int success)
+{
+    acutest_test_data_[i].flags |= success ? ACUTEST_FLAG_SUCCESS_ : ACUTEST_FLAG_FAILURE_;
+}
+
+static void
+acutest_set_duration_(int i, double duration)
+{
+    acutest_test_data_[i].duration = duration;
+}
+
+static int
+acutest_name_contains_word_(const char* name, const char* pattern)
+{
+    static const char word_delim[] = " \t-_/.,:;";
+    const char* substr;
+    size_t pattern_len;
+
+    pattern_len = strlen(pattern);
+
+    substr = strstr(name, pattern);
+    while(substr != NULL) {
+        int starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
+        int ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL);
+
+        if(starts_on_word_boundary && ends_on_word_boundary)
+            return 1;
+
+        substr = strstr(substr+1, pattern);
+    }
+
+    return 0;
+}
+
+static int
+acutest_lookup_(const char* pattern)
+{
+    int i;
+    int n = 0;
+
+    /* Try exact match. */
+    for(i = 0; i < (int) acutest_list_size_; i++) {
+        if(strcmp(acutest_list_[i].name, pattern) == 0) {
+            acutest_remember_(i);
+            n++;
+            break;
+        }
+    }
+    if(n > 0)
+        return n;
+
+    /* Try word match. */
+    for(i = 0; i < (int) acutest_list_size_; i++) {
+        if(acutest_name_contains_word_(acutest_list_[i].name, pattern)) {
+            acutest_remember_(i);
+            n++;
+        }
+    }
+    if(n > 0)
+        return n;
+
+    /* Try relaxed match. */
+    for(i = 0; i < (int) acutest_list_size_; i++) {
+        if(strstr(acutest_list_[i].name, pattern) != NULL) {
+            acutest_remember_(i);
+            n++;
+        }
+    }
+
+    return n;
+}
+
+
+/* Called if anything goes bad in Acutest, or if the unit test ends in other
+ * way then by normal returning from its function (e.g. exception or some
+ * abnormal child process termination). */
+static void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
+acutest_error_(const char* fmt, ...)
+{
+    if(acutest_verbose_level_ == 0)
+        return;
+
+    if(acutest_verbose_level_ >= 2) {
+        va_list args;
+
+        acutest_line_indent_(1);
+        if(acutest_verbose_level_ >= 3)
+            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "ERROR: ");
+        va_start(args, fmt);
+        vprintf(fmt, args);
+        va_end(args);
+        printf("\n");
+    }
+
+    if(acutest_verbose_level_ >= 3) {
+        printf("\n");
+    }
+}
+
+/* Call directly the given test unit function. */
+static int
+acutest_do_run_(const struct acutest_test_* test, int index)
+{
+    int status = -1;
+
+    acutest_was_aborted_ = 0;
+    acutest_current_test_ = test;
+    acutest_current_index_ = index;
+    acutest_test_failures_ = 0;
+    acutest_test_already_logged_ = 0;
+    acutest_cond_failed_ = 0;
+
+#ifdef __cplusplus
+    try {
+#endif
+        acutest_init_(test->name);
+        acutest_begin_test_line_(test);
+
+        /* This is good to do in case the test unit crashes. */
+        fflush(stdout);
+        fflush(stderr);
+
+        if(!acutest_worker_) {
+            acutest_abort_has_jmp_buf_ = 1;
+            if(setjmp(acutest_abort_jmp_buf_) != 0) {
+                acutest_was_aborted_ = 1;
+                goto aborted;
+            }
+        }
+
+        acutest_timer_get_time_(&acutest_timer_start_);
+        test->func();
+aborted:
+        acutest_abort_has_jmp_buf_ = 0;
+        acutest_timer_get_time_(&acutest_timer_end_);
+
+        if(acutest_verbose_level_ >= 3) {
+            acutest_line_indent_(1);
+            if(acutest_test_failures_ == 0) {
+                acutest_colored_printf_(ACUTEST_COLOR_GREEN_INTENSIVE_, "SUCCESS: ");
+                printf("All conditions have passed.\n");
+
+                if(acutest_timer_) {
+                    acutest_line_indent_(1);
+                    printf("Duration: ");
+                    acutest_timer_print_diff_();
+                    printf("\n");
+                }
+            } else {
+                acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
+                if(!acutest_was_aborted_) {
+                    printf("%d condition%s %s failed.\n",
+                            acutest_test_failures_,
+                            (acutest_test_failures_ == 1) ? "" : "s",
+                            (acutest_test_failures_ == 1) ? "has" : "have");
+                } else {
+                    printf("Aborted.\n");
+                }
+            }
+            printf("\n");
+        } else if(acutest_verbose_level_ >= 1 && acutest_test_failures_ == 0) {
+            acutest_finish_test_line_(0);
+        }
+
+        status = (acutest_test_failures_ == 0) ? 0 : -1;
+
+#ifdef __cplusplus
+    } catch(std::exception& e) {
+        const char* what = e.what();
+        acutest_check_(0, NULL, 0, "Threw std::exception");
+        if(what != NULL)
+            acutest_message_("std::exception::what(): %s", what);
+
+        if(acutest_verbose_level_ >= 3) {
+            acutest_line_indent_(1);
+            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
+            printf("C++ exception.\n\n");
+        }
+    } catch(...) {
+        acutest_check_(0, NULL, 0, "Threw an exception");
+
+        if(acutest_verbose_level_ >= 3) {
+            acutest_line_indent_(1);
+            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
+            printf("C++ exception.\n\n");
+        }
+    }
+#endif
+
+    acutest_fini_(test->name);
+    acutest_case_(NULL);
+    acutest_current_test_ = NULL;
+
+    return status;
+}
+
+/* Trigger the unit test. If possible (and not suppressed) it starts a child
+ * process who calls acutest_do_run_(), otherwise it calls acutest_do_run_()
+ * directly. */
+static void
+acutest_run_(const struct acutest_test_* test, int index, int master_index)
+{
+    int failed = 1;
+    acutest_timer_type_ start, end;
+
+    acutest_current_test_ = test;
+    acutest_test_already_logged_ = 0;
+    acutest_timer_get_time_(&start);
+
+    if(!acutest_no_exec_) {
+
+#if defined(ACUTEST_UNIX_)
+
+        pid_t pid;
+        int exit_code;
+
+        /* Make sure the child starts with empty I/O buffers. */
+        fflush(stdout);
+        fflush(stderr);
+
+        pid = fork();
+        if(pid == (pid_t)-1) {
+            acutest_error_("Cannot fork. %s [%d]", strerror(errno), errno);
+            failed = 1;
+        } else if(pid == 0) {
+            /* Child: Do the test. */
+            acutest_worker_ = 1;
+            failed = (acutest_do_run_(test, index) != 0);
+            acutest_exit_(failed ? 1 : 0);
+        } else {
+            /* Parent: Wait until child terminates and analyze its exit code. */
+            waitpid(pid, &exit_code, 0);
+            if(WIFEXITED(exit_code)) {
+                switch(WEXITSTATUS(exit_code)) {
+                    case 0:   failed = 0; break;   /* test has passed. */
+                    case 1:   /* noop */ break;    /* "normal" failure. */
+                    default:  acutest_error_("Unexpected exit code [%d]", WEXITSTATUS(exit_code));
+                }
+            } else if(WIFSIGNALED(exit_code)) {
+                char tmp[32];
+                const char* signame;
+                switch(WTERMSIG(exit_code)) {
+                    case SIGINT:  signame = "SIGINT"; break;
+                    case SIGHUP:  signame = "SIGHUP"; break;
+                    case SIGQUIT: signame = "SIGQUIT"; break;
+                    case SIGABRT: signame = "SIGABRT"; break;
+                    case SIGKILL: signame = "SIGKILL"; break;
+                    case SIGSEGV: signame = "SIGSEGV"; break;
+                    case SIGILL:  signame = "SIGILL"; break;
+                    case SIGTERM: signame = "SIGTERM"; break;
+                    default:      sprintf(tmp, "signal %d", WTERMSIG(exit_code)); signame = tmp; break;
+                }
+                acutest_error_("Test interrupted by %s.", signame);
+            } else {
+                acutest_error_("Test ended in an unexpected way [%d].", exit_code);
+            }
+        }
+
+#elif defined(ACUTEST_WIN_)
+
+        char buffer[512] = {0};
+        STARTUPINFOA startupInfo;
+        PROCESS_INFORMATION processInfo;
+        DWORD exitCode;
+
+        /* Windows has no fork(). So we propagate all info into the child
+         * through a command line arguments. */
+        _snprintf(buffer, sizeof(buffer)-1,
+                 "%s --worker=%d %s --no-exec --no-summary %s --verbose=%d --color=%s -- \"%s\"",
+                 acutest_argv0_, index, acutest_timer_ ? "--time" : "",
+                 acutest_tap_ ? "--tap" : "", acutest_verbose_level_,
+                 acutest_colorize_ ? "always" : "never",
+                 test->name);
+        memset(&startupInfo, 0, sizeof(startupInfo));
+        startupInfo.cb = sizeof(STARTUPINFO);
+        if(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo)) {
+            WaitForSingleObject(processInfo.hProcess, INFINITE);
+            GetExitCodeProcess(processInfo.hProcess, &exitCode);
+            CloseHandle(processInfo.hThread);
+            CloseHandle(processInfo.hProcess);
+            failed = (exitCode != 0);
+            if(exitCode > 1) {
+                switch(exitCode) {
+                    case 3:             acutest_error_("Aborted."); break;
+                    case 0xC0000005:    acutest_error_("Access violation."); break;
+                    default:            acutest_error_("Test ended in an unexpected way [%lu].", exitCode); break;
+                }
+            }
+        } else {
+            acutest_error_("Cannot create unit test subprocess [%ld].", GetLastError());
+            failed = 1;
+        }
+
+#else
+
+        /* A platform where we don't know how to run child process. */
+        failed = (acutest_do_run_(test, index) != 0);
+
+#endif
+
+    } else {
+        /* Child processes suppressed through --no-exec. */
+        failed = (acutest_do_run_(test, index) != 0);
+    }
+    acutest_timer_get_time_(&end);
+
+    acutest_current_test_ = NULL;
+
+    acutest_stat_run_units_++;
+    if(failed)
+        acutest_stat_failed_units_++;
+
+    acutest_set_success_(master_index, !failed);
+    acutest_set_duration_(master_index, acutest_timer_diff_(start, end));
+}
+
+#if defined(ACUTEST_WIN_)
+/* Callback for SEH events. */
+static LONG CALLBACK
+acutest_seh_exception_filter_(EXCEPTION_POINTERS *ptrs)
+{
+    acutest_check_(0, NULL, 0, "Unhandled SEH exception");
+    acutest_message_("Exception code:    0x%08lx", ptrs->ExceptionRecord->ExceptionCode);
+    acutest_message_("Exception address: 0x%p", ptrs->ExceptionRecord->ExceptionAddress);
+
+    fflush(stdout);
+    fflush(stderr);
+
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+#endif
+
+
+#define ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_    0x0001
+#define ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_    0x0002
+
+#define ACUTEST_CMDLINE_OPTID_NONE_             0
+#define ACUTEST_CMDLINE_OPTID_UNKNOWN_          (-0x7fffffff + 0)
+#define ACUTEST_CMDLINE_OPTID_MISSINGARG_       (-0x7fffffff + 1)
+#define ACUTEST_CMDLINE_OPTID_BOGUSARG_         (-0x7fffffff + 2)
+
+typedef struct acutest_test_CMDLINE_OPTION_ {
+    char shortname;
+    const char* longname;
+    int id;
+    unsigned flags;
+} ACUTEST_CMDLINE_OPTION_;
+
+static int
+acutest_cmdline_handle_short_opt_group_(const ACUTEST_CMDLINE_OPTION_* options,
+                    const char* arggroup,
+                    int (*callback)(int /*optval*/, const char* /*arg*/))
+{
+    const ACUTEST_CMDLINE_OPTION_* opt;
+    int i;
+    int ret = 0;
+
+    for(i = 0; arggroup[i] != '\0'; i++) {
+        for(opt = options; opt->id != 0; opt++) {
+            if(arggroup[i] == opt->shortname)
+                break;
+        }
+
+        if(opt->id != 0  &&  !(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
+            ret = callback(opt->id, NULL);
+        } else {
+            /* Unknown option. */
+            char badoptname[3];
+            badoptname[0] = '-';
+            badoptname[1] = arggroup[i];
+            badoptname[2] = '\0';
+            ret = callback((opt->id != 0 ? ACUTEST_CMDLINE_OPTID_MISSINGARG_ : ACUTEST_CMDLINE_OPTID_UNKNOWN_),
+                            badoptname);
+        }
+
+        if(ret != 0)
+            break;
+    }
+
+    return ret;
+}
+
+#define ACUTEST_CMDLINE_AUXBUF_SIZE_  32
+
+static int
+acutest_cmdline_read_(const ACUTEST_CMDLINE_OPTION_* options, int argc, char** argv,
+                      int (*callback)(int /*optval*/, const char* /*arg*/))
+{
+
+    const ACUTEST_CMDLINE_OPTION_* opt;
+    char auxbuf[ACUTEST_CMDLINE_AUXBUF_SIZE_+1];
+    int after_doubledash = 0;
+    int i = 1;
+    int ret = 0;
+
+    auxbuf[ACUTEST_CMDLINE_AUXBUF_SIZE_] = '\0';
+
+    while(i < argc) {
+        if(after_doubledash  ||  strcmp(argv[i], "-") == 0) {
+            /* Non-option argument. */
+            ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
+        } else if(strcmp(argv[i], "--") == 0) {
+            /* End of options. All the remaining members are non-option arguments. */
+            after_doubledash = 1;
+        } else if(argv[i][0] != '-') {
+            /* Non-option argument. */
+            ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
+        } else {
+            for(opt = options; opt->id != 0; opt++) {
+                if(opt->longname != NULL  &&  strncmp(argv[i], "--", 2) == 0) {
+                    size_t len = strlen(opt->longname);
+                    if(strncmp(argv[i]+2, opt->longname, len) == 0) {
+                        /* Regular long option. */
+                        if(argv[i][2+len] == '\0') {
+                            /* with no argument provided. */
+                            if(!(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_))
+                                ret = callback(opt->id, NULL);
+                            else
+                                ret = callback(ACUTEST_CMDLINE_OPTID_MISSINGARG_, argv[i]);
+                            break;
+                        } else if(argv[i][2+len] == '=') {
+                            /* with an argument provided. */
+                            if(opt->flags & (ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ | ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
+                                ret = callback(opt->id, argv[i]+2+len+1);
+                            } else {
+                                sprintf(auxbuf, "--%s", opt->longname);
+                                ret = callback(ACUTEST_CMDLINE_OPTID_BOGUSARG_, auxbuf);
+                            }
+                            break;
+                        } else {
+                            continue;
+                        }
+                    }
+                } else if(opt->shortname != '\0'  &&  argv[i][0] == '-') {
+                    if(argv[i][1] == opt->shortname) {
+                        /* Regular short option. */
+                        if(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_) {
+                            if(argv[i][2] != '\0')
+                                ret = callback(opt->id, argv[i]+2);
+                            else if(i+1 < argc)
+                                ret = callback(opt->id, argv[++i]);
+                            else
+                                ret = callback(ACUTEST_CMDLINE_OPTID_MISSINGARG_, argv[i]);
+                            break;
+                        } else {
+                            ret = callback(opt->id, NULL);
+
+                            /* There might be more (argument-less) short options
+                             * grouped together. */
+                            if(ret == 0  &&  argv[i][2] != '\0')
+                                ret = acutest_cmdline_handle_short_opt_group_(options, argv[i]+2, callback);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if(opt->id == 0) {  /* still not handled? */
+                if(argv[i][0] != '-') {
+                    /* Non-option argument. */
+                    ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
+                } else {
+                    /* Unknown option. */
+                    char* badoptname = argv[i];
+
+                    if(strncmp(badoptname, "--", 2) == 0) {
+                        /* Strip any argument from the long option. */
+                        char* assignment = strchr(badoptname, '=');
+                        if(assignment != NULL) {
+                            size_t len = assignment - badoptname;
+                            if(len > ACUTEST_CMDLINE_AUXBUF_SIZE_)
+                                len = ACUTEST_CMDLINE_AUXBUF_SIZE_;
+                            strncpy(auxbuf, badoptname, len);
+                            auxbuf[len] = '\0';
+                            badoptname = auxbuf;
+                        }
+                    }
+
+                    ret = callback(ACUTEST_CMDLINE_OPTID_UNKNOWN_, badoptname);
+                }
+            }
+        }
+
+        if(ret != 0)
+            return ret;
+        i++;
+    }
+
+    return ret;
+}
+
+static void
+acutest_help_(void)
+{
+    printf("Usage: %s [options] [test...]\n", acutest_argv0_);
+    printf("\n");
+    printf("Run the specified unit tests; or if the option '--skip' is used, run all\n");
+    printf("tests in the suite but those listed.  By default, if no tests are specified\n");
+    printf("on the command line, all unit tests in the suite are run.\n");
+    printf("\n");
+    printf("Options:\n");
+    printf("  -s, --skip            Execute all unit tests but the listed ones\n");
+    printf("      --exec[=WHEN]     If supported, execute unit tests as child processes\n");
+    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
+    printf("  -E, --no-exec         Same as --exec=never\n");
+#if defined ACUTEST_WIN_
+    printf("  -t, --time            Measure test duration\n");
+#elif defined ACUTEST_HAS_POSIX_TIMER_
+    printf("  -t, --time            Measure test duration (real time)\n");
+    printf("      --time=TIMER      Measure test duration, using given timer\n");
+    printf("                          (TIMER is one of 'real', 'cpu')\n");
+#endif
+    printf("      --no-summary      Suppress printing of test results summary\n");
+    printf("      --tap             Produce TAP-compliant output\n");
+    printf("                          (See https://testanything.org/)\n");
+    printf("  -x, --xml-output=FILE Enable XUnit output to the given file\n");
+    printf("  -l, --list            List unit tests in the suite and exit\n");
+    printf("  -v, --verbose         Make output more verbose\n");
+    printf("      --verbose=LEVEL   Set verbose level to LEVEL:\n");
+    printf("                          0 ... Be silent\n");
+    printf("                          1 ... Output one line per test (and summary)\n");
+    printf("                          2 ... As 1 and failed conditions (this is default)\n");
+    printf("                          3 ... As 1 and all conditions (and extended summary)\n");
+    printf("  -q, --quiet           Same as --verbose=0\n");
+    printf("      --color[=WHEN]    Enable colorized output\n");
+    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
+    printf("      --no-color        Same as --color=never\n");
+    printf("  -h, --help            Display this help and exit\n");
+
+    if(acutest_list_size_ < 16) {
+        printf("\n");
+        acutest_list_names_();
+    }
+}
+
+static const ACUTEST_CMDLINE_OPTION_ acutest_cmdline_options_[] = {
+    { 's',  "skip",         's', 0 },
+    {  0,   "exec",         'e', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
+    { 'E',  "no-exec",      'E', 0 },
+#if defined ACUTEST_WIN_
+    { 't',  "time",         't', 0 },
+    {  0,   "timer",        't', 0 },   /* kept for compatibility */
+#elif defined ACUTEST_HAS_POSIX_TIMER_
+    { 't',  "time",         't', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
+    {  0,   "timer",        't', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },  /* kept for compatibility */
+#endif
+    {  0,   "no-summary",   'S', 0 },
+    {  0,   "tap",          'T', 0 },
+    { 'l',  "list",         'l', 0 },
+    { 'v',  "verbose",      'v', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
+    { 'q',  "quiet",        'q', 0 },
+    {  0,   "color",        'c', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
+    {  0,   "no-color",     'C', 0 },
+    { 'h',  "help",         'h', 0 },
+    {  0,   "worker",       'w', ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_ },  /* internal */
+    { 'x',  "xml-output",   'x', ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_ },
+    {  0,   NULL,            0,  0 }
+};
+
+static int
+acutest_cmdline_callback_(int id, const char* arg)
+{
+    switch(id) {
+        case 's':
+            acutest_skip_mode_ = 1;
+            break;
+
+        case 'e':
+            if(arg == NULL || strcmp(arg, "always") == 0) {
+                acutest_no_exec_ = 0;
+            } else if(strcmp(arg, "never") == 0) {
+                acutest_no_exec_ = 1;
+            } else if(strcmp(arg, "auto") == 0) {
+                /*noop*/
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --exec.\n", acutest_argv0_, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+                acutest_exit_(2);
+            }
+            break;
+
+        case 'E':
+            acutest_no_exec_ = 1;
+            break;
+
+        case 't':
+#if defined ACUTEST_WIN_  ||  defined ACUTEST_HAS_POSIX_TIMER_
+            if(arg == NULL || strcmp(arg, "real") == 0) {
+                acutest_timer_ = 1;
+    #ifndef ACUTEST_WIN_
+            } else if(strcmp(arg, "cpu") == 0) {
+                acutest_timer_ = 2;
+    #endif
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --time.\n", acutest_argv0_, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+                acutest_exit_(2);
+            }
+#endif
+            break;
+
+        case 'S':
+            acutest_no_summary_ = 1;
+            break;
+
+        case 'T':
+            acutest_tap_ = 1;
+            break;
+
+        case 'l':
+            acutest_list_names_();
+            acutest_exit_(0);
+            break;
+
+        case 'v':
+            acutest_verbose_level_ = (arg != NULL ? atoi(arg) : acutest_verbose_level_+1);
+            break;
+
+        case 'q':
+            acutest_verbose_level_ = 0;
+            break;
+
+        case 'c':
+            if(arg == NULL || strcmp(arg, "always") == 0) {
+                acutest_colorize_ = 1;
+            } else if(strcmp(arg, "never") == 0) {
+                acutest_colorize_ = 0;
+            } else if(strcmp(arg, "auto") == 0) {
+                /*noop*/
+            } else {
+                fprintf(stderr, "%s: Unrecognized argument '%s' for option --color.\n", acutest_argv0_, arg);
+                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+                acutest_exit_(2);
+            }
+            break;
+
+        case 'C':
+            acutest_colorize_ = 0;
+            break;
+
+        case 'h':
+            acutest_help_();
+            acutest_exit_(0);
+            break;
+
+        case 'w':
+            acutest_worker_ = 1;
+            acutest_worker_index_ = atoi(arg);
+            break;
+        case 'x':
+            acutest_xml_output_ = fopen(arg, "w");
+            if (!acutest_xml_output_) {
+                fprintf(stderr, "Unable to open '%s': %s\n", arg, strerror(errno));
+                acutest_exit_(2);
+            }
+            break;
+
+        case 0:
+            if(acutest_lookup_(arg) == 0) {
+                fprintf(stderr, "%s: Unrecognized unit test '%s'\n", acutest_argv0_, arg);
+                fprintf(stderr, "Try '%s --list' for list of unit tests.\n", acutest_argv0_);
+                acutest_exit_(2);
+            }
+            break;
+
+        case ACUTEST_CMDLINE_OPTID_UNKNOWN_:
+            fprintf(stderr, "Unrecognized command line option '%s'.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+            acutest_exit_(2);
+            break;
+
+        case ACUTEST_CMDLINE_OPTID_MISSINGARG_:
+            fprintf(stderr, "The command line option '%s' requires an argument.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+            acutest_exit_(2);
+            break;
+
+        case ACUTEST_CMDLINE_OPTID_BOGUSARG_:
+            fprintf(stderr, "The command line option '%s' does not expect an argument.\n", arg);
+            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
+            acutest_exit_(2);
+            break;
+    }
+
+    return 0;
+}
+
+
+#ifdef ACUTEST_LINUX_
+static int
+acutest_is_tracer_present_(void)
+{
+    /* Must be large enough so the line 'TracerPid: ${PID}' can fit in. */
+    static const int OVERLAP = 32;
+
+    char buf[256+OVERLAP+1];
+    int tracer_present = 0;
+    int fd;
+    size_t n_read = 0;
+
+    fd = open("/proc/self/status", O_RDONLY);
+    if(fd == -1)
+        return 0;
+
+    while(1) {
+        static const char pattern[] = "TracerPid:";
+        const char* field;
+
+        while(n_read < sizeof(buf) - 1) {
+            ssize_t n;
+
+            n = read(fd, buf + n_read, sizeof(buf) - 1 - n_read);
+            if(n <= 0)
+                break;
+            n_read += n;
+        }
+        buf[n_read] = '\0';
+
+        field = strstr(buf, pattern);
+        if(field != NULL  &&  field < buf + sizeof(buf) - OVERLAP) {
+            pid_t tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
+            tracer_present = (tracer_pid != 0);
+            break;
+        }
+
+        if(n_read == sizeof(buf)-1) {
+            memmove(buf, buf + sizeof(buf)-1 - OVERLAP, OVERLAP);
+            n_read = OVERLAP;
+        } else {
+            break;
+        }
+    }
+
+    close(fd);
+    return tracer_present;
+}
+#endif
+
+int
+main(int argc, char** argv)
+{
+    int i;
+
+    acutest_argv0_ = argv[0];
+
+#if defined ACUTEST_UNIX_
+    acutest_colorize_ = isatty(STDOUT_FILENO);
+#elif defined ACUTEST_WIN_
+ #if defined _BORLANDC_
+    acutest_colorize_ = isatty(_fileno(stdout));
+ #else
+    acutest_colorize_ = _isatty(_fileno(stdout));
+ #endif
+#else
+    acutest_colorize_ = 0;
+#endif
+
+    /* Count all test units */
+    acutest_list_size_ = 0;
+    for(i = 0; acutest_list_[i].func != NULL; i++)
+        acutest_list_size_++;
+
+    acutest_test_data_ = (struct acutest_test_data_*)calloc(acutest_list_size_, sizeof(struct acutest_test_data_));
+    if(acutest_test_data_ == NULL) {
+        fprintf(stderr, "Out of memory.\n");
+        acutest_exit_(2);
+    }
+
+    /* Parse options */
+    acutest_cmdline_read_(acutest_cmdline_options_, argc, argv, acutest_cmdline_callback_);
+
+    /* Initialize the proper timer. */
+    acutest_timer_init_();
+
+#if defined(ACUTEST_WIN_)
+    SetUnhandledExceptionFilter(acutest_seh_exception_filter_);
+#ifdef _MSC_VER
+    _set_abort_behavior(0, _WRITE_ABORT_MSG);
+#endif
+#endif
+
+    /* By default, we want to run all tests. */
+    if(acutest_count_ == 0) {
+        for(i = 0; acutest_list_[i].func != NULL; i++)
+            acutest_remember_(i);
+    }
+
+    /* Guess whether we want to run unit tests as child processes. */
+    if(acutest_no_exec_ < 0) {
+        acutest_no_exec_ = 0;
+
+        if(acutest_count_ <= 1) {
+            acutest_no_exec_ = 1;
+        } else {
+#ifdef ACUTEST_WIN_
+            if(IsDebuggerPresent())
+                acutest_no_exec_ = 1;
+#endif
+#ifdef ACUTEST_LINUX_
+            if(acutest_is_tracer_present_())
+                acutest_no_exec_ = 1;
+#endif
+#ifdef RUNNING_ON_VALGRIND
+            /* RUNNING_ON_VALGRIND is provided by optionally included <valgrind.h> */
+            if(RUNNING_ON_VALGRIND)
+                acutest_no_exec_ = 1;
+#endif
+        }
+    }
+
+    if(acutest_tap_) {
+        /* TAP requires we know test result ("ok", "not ok") before we output
+         * anything about the test, and this gets problematic for larger verbose
+         * levels. */
+        if(acutest_verbose_level_ > 2)
+            acutest_verbose_level_ = 2;
+
+        /* TAP harness should provide some summary. */
+        acutest_no_summary_ = 1;
+
+        if(!acutest_worker_)
+            printf("1..%d\n", (int) acutest_count_);
+    }
+
+    int index = acutest_worker_index_;
+    for(i = 0; acutest_list_[i].func != NULL; i++) {
+        int run = (acutest_test_data_[i].flags & ACUTEST_FLAG_RUN_);
+        if (acutest_skip_mode_) /* Run all tests except those listed. */
+            run = !run;
+        if(run)
+            acutest_run_(&acutest_list_[i], index++, i);
+    }
+
+    /* Write a summary */
+    if(!acutest_no_summary_ && acutest_verbose_level_ >= 1) {
+        if(acutest_verbose_level_ >= 3) {
+            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Summary:\n");
+
+            printf("  Count of all unit tests:     %4d\n", (int) acutest_list_size_);
+            printf("  Count of run unit tests:     %4d\n", acutest_stat_run_units_);
+            printf("  Count of failed unit tests:  %4d\n", acutest_stat_failed_units_);
+            printf("  Count of skipped unit tests: %4d\n", (int) acutest_list_size_ - acutest_stat_run_units_);
+        }
+
+        if(acutest_stat_failed_units_ == 0) {
+            acutest_colored_printf_(ACUTEST_COLOR_GREEN_INTENSIVE_, "SUCCESS:");
+            printf(" All unit tests have passed.\n");
+        } else {
+            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED:");
+            printf(" %d of %d unit tests %s failed.\n",
+                    acutest_stat_failed_units_, acutest_stat_run_units_,
+                    (acutest_stat_failed_units_ == 1) ? "has" : "have");
+        }
+
+        if(acutest_verbose_level_ >= 3)
+            printf("\n");
+    }
+
+    if (acutest_xml_output_) {
+#if defined ACUTEST_UNIX_
+        char *suite_name = basename(argv[0]);
+#elif defined ACUTEST_WIN_
+        char suite_name[_MAX_FNAME];
+        _splitpath(argv[0], NULL, NULL, suite_name, NULL);
+#else
+        const char *suite_name = argv[0];
+#endif
+        fprintf(acutest_xml_output_, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+        fprintf(acutest_xml_output_, "<testsuite name=\"%s\" tests=\"%d\" errors=\"%d\" failures=\"%d\" skip=\"%d\">\n",
+            suite_name, (int)acutest_list_size_, acutest_stat_failed_units_, acutest_stat_failed_units_,
+            (int)acutest_list_size_ - acutest_stat_run_units_);
+        for(i = 0; acutest_list_[i].func != NULL; i++) {
+            struct acutest_test_data_ *details = &acutest_test_data_[i];
+            fprintf(acutest_xml_output_, "  <testcase name=\"%s\" time=\"%.2f\">\n", acutest_list_[i].name, details->duration);
+            if (details->flags & ACUTEST_FLAG_FAILURE_)
+                fprintf(acutest_xml_output_, "    <failure />\n");
+            if (!(details->flags & ACUTEST_FLAG_FAILURE_) && !(details->flags & ACUTEST_FLAG_SUCCESS_))
+                fprintf(acutest_xml_output_, "    <skipped />\n");
+            fprintf(acutest_xml_output_, "  </testcase>\n");
+        }
+        fprintf(acutest_xml_output_, "</testsuite>\n");
+        fclose(acutest_xml_output_);
+    }
+
+    acutest_cleanup_();
+
+    return (acutest_stat_failed_units_ == 0) ? 0 : 1;
+}
+
+
+#endif  /* #ifndef TEST_NO_MAIN */
+
+#ifdef _MSC_VER
+    #pragma warning(pop)
+#endif
+
+#ifdef __cplusplus
+    }  /* extern "C" */
+#endif
+
+#endif  /* #ifndef ACUTEST_H */
diff --git a/fluent-bit/lib/ctraces/tests/span.c b/fluent-bit/lib/ctraces/tests/span.c
new file mode 100644
index 000000000..9344d68ea
--- /dev/null
+++ b/fluent-bit/lib/ctraces/tests/span.c
@@ -0,0 +1,92 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CTraces
+ *  =======
+ *  Copyright 2022 The CTraces Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <ctraces/ctraces.h>
+#include <ctraces/ctr_span.h>
+
+#include <cfl/cfl.h>
+#include <cfl/cfl_array.h>
+#include <cfl/cfl_kvlist.h>
+
+#include "ctr_tests.h"
+
+void test_span()
+{
+    int ret;
+    struct ctrace *ctx;
+    struct ctrace_span *span_root;
+    struct ctrace_span *span_child;
+    struct ctrace_resource_span *resource_span;
+    struct ctrace_scope_span *scope_span;
+    struct ctrace_id *id;
+    struct cfl_array *array;
+    struct cfl_kvlist *kvlist;
+
+    ctx = ctr_create(NULL);
+
+    resource_span = ctr_resource_span_create(ctx);
+    scope_span = ctr_scope_span_create(resource_span);
+
+    /* create root span */
+    span_root = ctr_span_create(ctx, scope_span, "main", NULL);
+    TEST_CHECK(span_root != NULL);
+    TEST_CHECK(span_root->kind == CTRACE_SPAN_INTERNAL);
+
+    /* set the span root a random id */
+    id = ctr_id_create_random(CTR_ID_OTEL_SPAN_SIZE);
+    TEST_CHECK(id != NULL);
+    ctr_span_set_span_id_with_cid(span_root, id);
+
+    /* id is not longer needed */
+    ctr_id_destroy(id);
+
+    span_child = ctr_span_create(ctx, scope_span, "do-work", span_root);
+    TEST_CHECK(span_child != NULL);
+
+    /* set span kind */
+    ret = ctr_span_kind_set(span_child, CTRACE_SPAN_CONSUMER);
+    TEST_CHECK(ret == 0);
+    TEST_CHECK(span_child->kind == CTRACE_SPAN_CONSUMER);
+
+    /* parent id check */
+    ret = ctr_id_cmp(span_child->parent_span_id, span_root->span_id);
+    TEST_CHECK(ret == 0);
+
+    /* add attributes to span_child */
+    ctr_span_set_attribute_string(span_child, "agent", "fluent bit");
+    ctr_span_set_attribute_bool(span_child, "bool_t", 1);
+    ctr_span_set_attribute_bool(span_child, "bool_f", 0);
+    ctr_span_set_attribute_int64(span_child, "integer", 123456789);
+    ctr_span_set_attribute_double(span_child, "double", 1.5);
+
+    array = cfl_array_create(128);
+    TEST_CHECK(array != NULL);
+    ctr_span_set_attribute_array(span_child, "array", array);
+
+    kvlist = cfl_kvlist_create();
+    TEST_CHECK(kvlist != NULL);
+    ctr_span_set_attribute_kvlist(span_child, "kvlist", kvlist);
+
+    ctr_destroy(ctx);
+}
+
+TEST_LIST = {
+    {"span", test_span},
+    { 0 }
+};