datadog 2.4.0 → 2.44.0

data/lib/datadog/tracing/distributed/trace_state/open_telemetry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "../../sampling/rate_sampler"
+require_relative "ext"
+
+module Datadog
+  module Tracing
+    module Distributed
+      class TraceState
+        # Encodes consistent probability sampling in the OpenTelemetry `ot=` tracestate member.
+        # @see https://opentelemetry.io/docs/specs/otel/trace/tracestate-probability-sampling/
+        class OpenTelemetry
+          class << self
+            def from_digest(digest, propagate_sampling: true)
+              new(
+                random_value: (digest.trace_otel_random_value if propagate_sampling),
+                threshold: (digest.trace_otel_threshold if propagate_sampling),
+                unknown_fields: digest.trace_otel_unknown_fields,
+              )
+            end
+
+            # Parses known fields and retains unknown fields for propagation.
+            def from_tracestate_member(value)
+              return new unless value
+
+              # @type var random_value: ::String?
+              # @type var threshold: ::String?
+              random_value = nil
+              threshold = nil
+              unknown = []
+
+              value.split(";").each do |pair|
+                key, field = pair.split(":", 2)
+                case key
+                when "rv"
+                  random_value = field
+                when "th"
+                  threshold = field
+                else
+                  unknown << pair
+                end
+              end
+
+              threshold = nil if threshold && !Ext::OpenTelemetry::VALID_THRESHOLD.match?(threshold)
+              random_value = nil if random_value && !Ext::OpenTelemetry::VALID_RANDOM_VALUE.match?(random_value)
+
+              new(
+                random_value: random_value,
+                threshold: threshold,
+                unknown_fields: unknown.empty? ? nil : "#{unknown.join(";")};",
+              )
+            end
+          end
+
+          attr_reader :random_value, :threshold, :unknown_fields
+
+          def initialize(random_value: nil, threshold: nil, unknown_fields: nil)
+            @random_value = random_value
+            @threshold = threshold
+            @unknown_fields = unknown_fields
+          end
+
+          # Resolves fields that represent the trace's current sampling decision.
+          def outbound(
+            trace_id:,
+            sampling_priority:,
+            decision_maker:,
+            applied_rate:,
+            rate_limiter_rate:,
+            distributed_sampling_priority:
+          )
+            if Ext::OpenTelemetry::NON_PROBABILITY_DECISIONS.include?(decision_maker)
+              return self.class.new(random_value: random_value, unknown_fields: unknown_fields)
+            end
+
+            trace_kept = sampling_priority && sampling_priority >= Sampling::Ext::Priority::AUTO_KEEP
+            if rate_limiter_rate && !trace_kept
+              return self.class.new(random_value: random_value, unknown_fields: unknown_fields)
+            end
+
+            return self if random_value || threshold
+            return self.class.new(unknown_fields: unknown_fields) if distributed_sampling_priority || !applied_rate
+
+            outbound_threshold = threshold_for(applied_rate)
+            outbound_random_value = reconcile_random_value(
+              random_value_for(trace_id),
+              outbound_threshold,
+              !!trace_kept
+            )
+            self.class.new(
+              random_value: format_random_value(outbound_random_value),
+              threshold: format_threshold(outbound_threshold),
+              unknown_fields: unknown_fields,
+            )
+          end
+
+          def to_s
+            fields = []
+            fields << "rv:#{random_value}" if random_value
+            fields << "th:#{threshold}" if threshold
+            fields.concat(unknown_fields.chomp(";").split(";")) if unknown_fields
+
+            value = +""
+            fields.each do |field|
+              separator = value.empty? ? "" : ";"
+              break if value.bytesize + separator.bytesize + field.bytesize > Ext::TRACESTATE_VALUE_SIZE_LIMIT
+
+              value << separator << field
+            end
+            value.empty? ? "" : "ot=#{value}"
+          end
+
+          private
+
+          # Converts Datadog's Knuth hash into OTel's 56-bit random value.
+          def random_value_for(trace_id)
+            hash = (trace_id * Sampling::RateSampler::KNUTH_FACTOR) % Ext::OpenTelemetry::UINT64_MODULO
+            (~hash & Ext::OpenTelemetry::UINT64_MASK) >> 8
+          end
+
+          # Converts a sample rate into a 56-bit rejection threshold.
+          def threshold_for(rate)
+            threshold = ((1.0 - rate) * Ext::OpenTelemetry::MAX_THRESHOLD).round
+            return 0 if threshold < 0
+            return Ext::OpenTelemetry::MAX_ENCODABLE_THRESHOLD if threshold > Ext::OpenTelemetry::MAX_ENCODABLE_THRESHOLD
+
+            threshold
+          end
+
+          # Preserve Datadog's 64-bit decision after expressing it with 56-bit OTel values.
+          def reconcile_random_value(random_value, threshold, kept)
+            if kept && random_value < threshold
+              threshold
+            elsif !kept && random_value >= threshold
+              [threshold - 1, 0].max
+            else
+              random_value
+            end
+          end
+
+          def format_random_value(random_value)
+            format("%014x", random_value)
+          end
+
+          # OTel thresholds omit trailing zero nibbles but retain leading zeroes.
+          def format_threshold(threshold)
+            return "0" if threshold.zero?
+
+            trailing_nibbles = ((threshold & -threshold).bit_length - 1) / 4
+            (threshold >> (trailing_nibbles * 4)).to_s(16).rjust(14 - trailing_nibbles, "0")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/distributed/trace_state.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../../core/utils"
+require_relative "trace_state/ext"
+require_relative "trace_state/datadog"
+require_relative "trace_state/open_telemetry"
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Parsed vendor state from a W3C `tracestate` header.
+      # @api private
+      class TraceState
+        class << self
+          def from_digest(digest, propagate_sampling: true)
+            new(
+              unknown_vendors: digest.trace_state,
+              datadog: Datadog.from_digest(digest),
+              open_telemetry: OpenTelemetry.from_digest(digest, propagate_sampling: propagate_sampling),
+            )
+          end
+
+          def serialize_digest(digest)
+            serialize(
+              unknown_vendors: digest.trace_state,
+              datadog: Datadog.from_digest(digest),
+              open_telemetry: OpenTelemetry.from_digest(digest),
+            )
+          end
+
+          # Parses owned members while retaining other vendors unchanged.
+          def extract(tracestate)
+            vendors = split(tracestate) || []
+            datadog_index = vendors.index { |vendor| vendor.start_with?("dd=") }
+            datadog_value = vendors.delete_at(datadog_index).delete_prefix("dd=") if datadog_index
+            otel_index = vendors.index { |vendor| vendor.start_with?("ot=") }
+            otel_value = vendors.delete_at(otel_index).delete_prefix("ot=") if otel_index
+
+            new(
+              unknown_vendors: vendors.empty? ? nil : vendors.join(","),
+              datadog: Datadog.from_tracestate_member(datadog_value),
+              open_telemetry: OpenTelemetry.from_tracestate_member(otel_value),
+            )
+          end
+
+          # Partial members must not be propagated, but complete members within the limits are retained.
+          def split(tracestate)
+            return if tracestate.nil? || tracestate.empty?
+
+            remove_last_vendor = false
+            if tracestate.bytesize > Ext::TRACESTATE_MAX_SIZE_LIMIT
+              remove_last_vendor = tracestate.byteslice(Ext::TRACESTATE_MAX_SIZE_LIMIT, 1) != ","
+              tracestate = tracestate.byteslice(0, Ext::TRACESTATE_MAX_SIZE_LIMIT + 1) #: String
+              tracestate = tracestate.chop
+            end
+
+            tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
+            return unless tracestate
+
+            vendors = tracestate.split(",", Ext::TRACESTATE_MAX_LIST_VENDORS + 1)
+            vendors.pop if vendors.length > Ext::TRACESTATE_MAX_LIST_VENDORS || remove_last_vendor
+            vendors.each(&:strip!)
+            vendors.pop while vendors.last == ""
+            vendors
+          end
+
+          private
+
+          def serialize(unknown_vendors:, datadog:, open_telemetry:)
+            leading_vendors = select_leading_vendors(datadog, open_telemetry)
+            vendors = split(unknown_vendors)
+
+            if leading_vendors.empty?
+              return unless vendors && !vendors.empty?
+
+              return vendors.join(",")
+            end
+
+            vendors&.reject! { |vendor| vendor.start_with?("dd=", "ot=") }
+
+            tracestate = leading_vendors.join(",")
+            if vendors && !vendors.empty?
+              vendors.first(Ext::TRACESTATE_MAX_LIST_VENDORS - leading_vendors.size).each do |vendor|
+                break if tracestate.bytesize + vendor.bytesize + 1 > Ext::TRACESTATE_MAX_SIZE_LIMIT
+
+                tracestate << "," << vendor
+              end
+            end
+
+            tracestate
+          end
+
+          def select_leading_vendors(datadog, open_telemetry)
+            leading_vendors = []
+            add_leading_vendor(leading_vendors, datadog)
+            add_leading_vendor(leading_vendors, open_telemetry)
+
+            leading_vendors
+          end
+
+          def add_leading_vendor(leading_vendors, state)
+            vendor = state.to_s
+            return if vendor.empty?
+
+            combined_size = leading_vendors.sum { |current| current.bytesize } +
+              leading_vendors.size + vendor.bytesize
+            leading_vendors << vendor if combined_size <= Ext::TRACESTATE_MAX_SIZE_LIMIT
+          end
+        end
+
+        attr_reader :unknown_vendors, :datadog, :open_telemetry
+
+        def initialize(unknown_vendors: nil, datadog: nil, open_telemetry: nil)
+          @unknown_vendors = unknown_vendors
+          @datadog = datadog || Datadog.new
+          @open_telemetry = open_telemetry || OpenTelemetry.new
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/event.rb

@@ -46,7 +46,7 @@ module Datadog
       end
 
       def subscribe(&block)
-        raise ArgumentError, 'Must give a block to subscribe!' unless block
+        raise ArgumentError, "Must give a block to subscribe!" unless block
 
         subscriptions << block
       end
@@ -59,13 +59,11 @@ module Datadog
 
       def publish(*args)
         subscriptions.each do |block|
-          begin
-            block.call(*args)
-          rescue StandardError => e
-            Datadog.logger.debug do
-              "Error while handling '#{name}' event with '#{block}': #{e.class.name} #{e.message} " \
-              "at #{Array(e.backtrace).first}"
-            end
+          block.call(*args)
+        rescue => e
+          Datadog.logger.debug do
+            "Error while handling '#{name}' event with '#{block}': #{e.class}: #{e.message} " \
+            "at #{Array(e.backtrace).first}"
           end
         end
 

data/lib/datadog/tracing/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Ext
+      TELEMETRY_METRICS_NAMESPACE = "tracers"
+    end
+  end
+end

data/lib/datadog/tracing/flush.rb

@@ -59,7 +59,7 @@ module Datadog
       class Finished < Base
         # Are all spans finished?
         def flush?(trace_op)
-          trace_op && trace_op.finished?
+          trace_op&.finished?
         end
       end
 

data/lib/datadog/tracing/metadata/analytics.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../analytics'
-require_relative 'ext'
+require_relative "../analytics"
+require_relative "ext"
 
 module Datadog
   module Tracing
@@ -12,7 +12,7 @@ module Datadog
           case key
           when Ext::Analytics::TAG_ENABLED
             # If true, set rate to 1.0, otherwise set 0.0.
-            value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
+            value = (value == true) ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
             Tracing::Analytics.set_sample_rate(self, value)
           when Ext::Analytics::TAG_SAMPLE_RATE
             Tracing::Analytics.set_sample_rate(self, value)

data/lib/datadog/tracing/metadata/errors.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../core/error'
+require_relative "../../core/error"
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module Tracing
@@ -10,17 +10,17 @@ module Datadog
       # Adds error tagging behavior
       # @public_api
       module Errors
-        def set_error(e)
+        def set_error(error)
           Datadog::Core.log_deprecation do
-            'Errors.set_error(..) is deprecated. ' \
-            'Use Errors.set_error_tags(..) instead.'
+            "Errors.set_error(..) is deprecated. " \
+            "Use Errors.set_error_tags(..) instead."
           end
-          set_error_tags(e)
+          set_error_tags(error)
         end
 
         # Mark the span with the given error.
-        def set_error_tags(e)
-          e = Core::Error.build_from(e)
+        def set_error_tags(error)
+          e = Core::Error.build_from(error)
 
           set_tag(Ext::Errors::TAG_TYPE, e.type) unless e.type.empty?
           set_tag(Ext::Errors::TAG_MSG, e.message) unless e.message.empty?

data/lib/datadog/tracing/metadata/ext.rb

@@ -10,42 +10,57 @@ module Datadog
       # @public_api
       module Ext
         # Name of package that was instrumented
-        TAG_COMPONENT = 'component'
+        TAG_COMPONENT = "component"
         # Type of operation being performed (e.g. )
-        TAG_OPERATION = 'operation'
+        TAG_OPERATION = "operation"
         # Hostname of external service interacted with
         #
         # This tag also doesn't strictly need to be a “hostname”. It can be a raw IP address and in some cases it
         # can even be a unix domain socket (i.e. postgres client setting host=/var/run/postgres).
         # It should be whatever the client uses to point at the server it’s trying to talk to.
-        TAG_PEER_HOSTNAME = 'peer.hostname'
+        TAG_PEER_HOSTNAME = "peer.hostname"
         # Name of external service that performed the work
-        TAG_PEER_SERVICE = 'peer.service'
+        TAG_PEER_SERVICE = "peer.service"
 
-        TAG_KIND = 'span.kind'
+        TAG_KIND = "span.kind"
 
         # Set this tag to `1.0` if the span is a Service Entry span.
-        TAG_TOP_LEVEL = '_dd.top_level'
+        TAG_TOP_LEVEL = "_dd.top_level"
 
         # Set to `1.0` if profiling is enabled together with tracing, and `0.0` otherwise
         # See Datadog-internal "RFC: Identifying which spans have profiling enabled " for details
-        TAG_PROFILING_ENABLED = '_dd.profiling.enabled'
+        TAG_PROFILING_ENABLED = "_dd.profiling.enabled"
+
+        TAG_APM_ENABLED = "_dd.apm.enabled"
+
+        # Declares whether the trace chunk was exported over OTLP (`"true"`) or the native protocol (`"false"`)
+        TAG_SDK_OTLP_EXPORT = "_dd.sdk.otlp_export"
+
+        # Set to the global service name when a span's service is overridden
+        TAG_BASE_SERVICE = "_dd.base_service"
+
+        # Set to the source of a span's service override: the component name for Datadog-instrumented spans
+        # (e.g. 'redis', 'pg'), or {SVC_SRC_MANUAL} for manually-instrumented spans
+        TAG_SVC_SRC = "_dd.svc_src"
+
+        # Value for {TAG_SVC_SRC} indicating that a span was manually instrumented via the Tracing API
+        SVC_SRC_MANUAL = "m"
 
         # Defines constants for trace analytics
         # @public_api
         module Analytics
           DEFAULT_SAMPLE_RATE = 1.0
-          TAG_ENABLED = 'analytics.enabled'
-          TAG_MEASURED = '_dd.measured'
-          TAG_SAMPLE_RATE = '_dd1.sr.eausr'
+          TAG_ENABLED = "analytics.enabled"
+          TAG_MEASURED = "_dd.measured"
+          TAG_SAMPLE_RATE = "_dd1.sr.eausr"
         end
 
         module AppTypes
-          TYPE_WEB = 'web'
-          TYPE_DB = 'db'
-          TYPE_CACHE = 'cache'
-          TYPE_WORKER = 'worker'
-          TYPE_CUSTOM = 'custom'
+          TYPE_WEB = "web"
+          TYPE_DB = "db"
+          TYPE_CACHE = "cache"
+          TYPE_WORKER = "worker"
+          TYPE_CUSTOM = "custom"
         end
 
         # @public_api
@@ -53,48 +68,63 @@ module Datadog
         module Distributed
           # What mechanism was used to make this trace's sampling decision.
           # @see Datadog::Tracing::Sampling::Ext::Mechanism
-          TAG_DECISION_MAKER = '_dd.p.dm'
+          TAG_DECISION_MAKER = "_dd.p.dm"
 
-          TAG_ORIGIN = '_dd.origin'
-          TAG_SAMPLING_PRIORITY = '_sampling_priority_v1'
+          # Bitmask for which product generated an event. E.g.: 2 for an AppSec event.
+          TAG_TRACE_SOURCE = "_dd.p.ts"
 
-          TAG_DD_PARENT_ID = '_dd.parent_id'
-          DD_PARENT_ID_DEFAULT = '0000000000000000'
+          TAG_ORIGIN = "_dd.origin"
+          TAG_SAMPLING_PRIORITY = "_sampling_priority_v1"
+
+          TAG_DD_PARENT_ID = "_dd.parent_id"
+          DD_PARENT_ID_DEFAULT = "0000000000000000"
+
+          # Knuth Sampling Rate: the sampling rate applied by agent-based or rule-based sampling.
+          # This is a propagated tag (prefixed with `_dd.p.`) that is included in `x-datadog-tags`.
+          TAG_KNUTH_SAMPLING_RATE = "_dd.p.ksr"
 
           # Trace tags with this prefix will propagate from a trace through distributed tracing.
           # Distributed headers tags with this prefix will be injected into the active trace.
-          TAGS_PREFIX = '_dd.p.'
+          TAGS_PREFIX = "_dd.p."
 
           # The distributed tag to carry hex encoded high order 64 bits of 127 bits trace id during
           # the context restricted with 64 bits. Such as, Datadog propagation and messagepack encoding
-          TID = 'tid'
+          TID = "tid"
           TAG_TID = TAGS_PREFIX + TID
         end
 
         # @public_api
         module Errors
           STATUS = 1
-          TAG_MSG = 'error.message'
-          TAG_STACK = 'error.stack'
-          TAG_TYPE = 'error.type'
+          TAG_MSG = "error.message"
+          TAG_STACK = "error.stack"
+          TAG_TYPE = "error.type"
+
+          # From https://opentelemetry.io/docs/specs/semconv/registry/attributes/exception/#exception-stacktrace
+          ATTRIBUTE_MESSAGE = "exception.message"
+          ATTRIBUTE_STACKTRACE = "exception.stacktrace"
+          ATTRIBUTE_TYPE = "exception.type"
+
+          # From https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/#exception-event
+          EVENT_NAME = "exception"
         end
 
         # @public_api
         module HTTP
-          ERROR_RANGE = (500...600).freeze
-          TAG_BASE_URL = 'http.base_url'
-          TAG_METHOD = 'http.method'
-          TAG_STATUS_CODE = 'http.status_code'
-          TAG_USER_AGENT = 'http.useragent'
-          TAG_URL = 'http.url'
-          TAG_ROUTE = 'http.route'
-          TAG_ROUTE_PATH = 'http.route.path'
+          TAG_BASE_URL = "http.base_url"
+          TAG_ENDPOINT = "http.endpoint"
+          TAG_METHOD = "http.method"
+          TAG_STATUS_CODE = "http.status_code"
+          TAG_USER_AGENT = "http.useragent"
+          TAG_URL = "http.url"
+          TAG_ROUTE = "http.route"
+          TAG_ROUTE_PATH = "http.route.path"
           TYPE_INBOUND = AppTypes::TYPE_WEB.freeze
-          TYPE_OUTBOUND = 'http'
-          TYPE_PROXY = 'proxy'
-          TYPE_TEMPLATE = 'template'
-          TAG_CLIENT_IP = 'http.client_ip'
-          HEADER_USER_AGENT = 'User-Agent'
+          TYPE_OUTBOUND = "http"
+          TYPE_PROXY = "proxy"
+          TYPE_TEMPLATE = "template"
+          TAG_CLIENT_IP = "http.client_ip"
+          HEADER_USER_AGENT = "User-Agent"
 
           # General header functionality
           module Headers
@@ -120,19 +150,19 @@ module Datadog
               # All other characters are replaced with an underscore.
               tag = name.to_s.strip
               tag.downcase!
-              tag.gsub!(INVALID_TAG_CHARACTERS, '_')
+              tag.gsub!(INVALID_TAG_CHARACTERS, "_")
 
               # Additional HTTP header normalization.
               #
               # Periods are replaced with an underscore.
-              tag.tr!('.', '_') unless allow_nested
+              tag.tr!(".", "_") unless allow_nested
               tag
             end
           end
 
           # Request headers
           module RequestHeaders
-            PREFIX = 'http.request.headers'
+            PREFIX = "http.request.headers"
 
             module_function
 
@@ -143,7 +173,7 @@ module Datadog
 
           # Response headers
           module ResponseHeaders
-            PREFIX = 'http.response.headers'
+            PREFIX = "http.response.headers"
 
             module_function
 
@@ -155,42 +185,42 @@ module Datadog
 
         # @public_api
         module NET
-          TAG_HOSTNAME = '_dd.hostname'
-          TAG_TARGET_HOST = 'out.host'
-          TAG_TARGET_PORT = 'out.port'
-          TAG_DESTINATION_NAME = 'network.destination.name'
-          TAG_DESTINATION_PORT = 'network.destination.port'
+          TAG_HOSTNAME = "_dd.hostname"
+          TAG_TARGET_HOST = "out.host"
+          TAG_TARGET_PORT = "out.port"
+          TAG_DESTINATION_NAME = "network.destination.name"
+          TAG_DESTINATION_PORT = "network.destination.port"
         end
 
         # @public_api
         module Sampling
-          TAG_AGENT_RATE = '_dd.agent_psr'
+          TAG_AGENT_RATE = "_dd.agent_psr"
 
           # If rule sampling is applied to a span, set this metric the sample rate configured for that rule.
           # This should be done regardless of sampling outcome.
-          TAG_RULE_SAMPLE_RATE = '_dd.rule_psr'
+          TAG_RULE_SAMPLE_RATE = "_dd.rule_psr"
 
           # If rate limiting is checked on a span, set this metric the effective rate limiting rate applied.
           # This should be done regardless of rate limiting outcome.
-          TAG_RATE_LIMITER_RATE = '_dd.limit_psr'
+          TAG_RATE_LIMITER_RATE = "_dd.limit_psr"
 
-          TAG_SAMPLE_RATE = '_sample_rate'
+          TAG_SAMPLE_RATE = "_sample_rate"
         end
 
         # @public_api
         module SQL
-          TYPE = 'sql'
-          TAG_QUERY = 'sql.query'
+          TYPE = "sql"
+          TAG_QUERY = "sql.query"
         end
 
         # @public_api
         module SpanKind
-          TAG_PROXY = 'proxy'
-          TAG_SERVER = 'server'
-          TAG_CLIENT = 'client'
-          TAG_PRODUCER = 'producer'
-          TAG_CONSUMER = 'consumer'
-          TAG_INTERNAL = 'internal'
+          TAG_PROXY = "proxy"
+          TAG_SERVER = "server"
+          TAG_CLIENT = "client"
+          TAG_PRODUCER = "producer"
+          TAG_CONSUMER = "consumer"
+          TAG_INTERNAL = "internal"
         end
 
         # @public_api

data/lib/datadog/tracing/metadata/metastruct.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Datadog
+  module Tracing
+    module Metadata
+      # This class is a data structure that is used to store
+      # complex metadata, such as an array of objects.
+      #
+      # It is serialized to MessagePack format when sent to the agent.
+      class Metastruct
+        extend Forwardable
+
+        def_delegators :@metastruct, :[], :[]=, :to_h
+
+        def initialize
+          @metastruct = {}
+        end
+
+        def to_msgpack(packer = nil)
+          # JRuby doesn't pass the packer
+          packer ||= MessagePack::Packer.new
+
+          packer.write(@metastruct.transform_values(&:to_msgpack))
+        end
+
+        def pretty_print(q)
+          q.seplist @metastruct.each do |key, value|
+            q.text "#{key} => #{value}"
+          end
+        end
+      end
+    end
+  end
+end