diff --git a/lib/prometheus/client/counter.rb b/lib/prometheus/client/counter.rb
index 28ec2f1e..07933182 100644
--- a/lib/prometheus/client/counter.rb
+++ b/lib/prometheus/client/counter.rb
@@ -10,11 +10,11 @@ def type
         :counter
       end
 
-      def increment(by: 1, labels: {})
+      def increment(by: 1, labels: {}, exemplar: nil)
         raise ArgumentError, 'increment must be a non-negative number' if by < 0
 
         label_set = label_set_for(labels)
-        @store.increment(labels: label_set, by: by)
+        @store.increment(labels: label_set, by: by, exemplar: exemplar)
       end
     end
   end
diff --git a/lib/prometheus/client/data_stores/direct_file_store.rb b/lib/prometheus/client/data_stores/direct_file_store.rb
index 1c09dc4d..5f41abf2 100644
--- a/lib/prometheus/client/data_stores/direct_file_store.rb
+++ b/lib/prometheus/client/data_stores/direct_file_store.rb
@@ -99,13 +99,13 @@ def synchronize
             end
           end
 
-          def set(labels:, val:)
+          def set(labels:, val:, exemplar: nil)
             in_process_sync do
               internal_store.write_value(store_key(labels), val.to_f)
             end
           end
 
-          def increment(labels:, by: 1)
+          def increment(labels:, by: 1, exemplar: nil)
             if @values_aggregation_mode == DirectFileStore::MOST_RECENT
               raise InvalidStoreSettingsError,
                     "The :most_recent aggregation does not support the use of increment"\
@@ -118,13 +118,13 @@ def increment(labels:, by: 1)
             end
           end
 
-          def get(labels:)
+          def get(labels:, with_exemplars: false)
             in_process_sync do
               internal_store.read_value(store_key(labels))
             end
           end
 
-          def all_values
+          def all_values(with_exemplars: false)
             stores_data = Hash.new{ |hash, key| hash[key] = [] }
 
             # There's no need to call `synchronize` here. We're opening a second handle to
diff --git a/lib/prometheus/client/data_stores/single_threaded.rb b/lib/prometheus/client/data_stores/single_threaded.rb
index f05cf813..6fec1042 100644
--- a/lib/prometheus/client/data_stores/single_threaded.rb
+++ b/lib/prometheus/client/data_stores/single_threaded.rb
@@ -1,3 +1,7 @@
+require "prometheus/client/value_with_exemplars"
+require "prometheus/client/exemplar_collection"
+require "prometheus/client/exemplar"
+
 module Prometheus
   module Client
     module DataStores
@@ -25,27 +29,41 @@ def validate_metric_settings(metric_settings:)
 
         class MetricStore
           def initialize
-            @internal_store = Hash.new { |hash, key| hash[key] = 0.0 }
+            @internal_store = Hash.new { |hash, key| hash[key] = Prometheus::Client::ValueWithExemplars.new }
           end
 
           def synchronize
             yield
           end
 
-          def set(labels:, val:)
-            @internal_store[labels] = val.to_f
+          def set(labels:, val:, exemplar: nil)
+            @internal_store[labels].set(value: val, exemplar: exemplar)
           end
 
-          def increment(labels:, by: 1)
-            @internal_store[labels] += by
+          def increment(labels:, by: 1, exemplar: nil)
+            @internal_store[labels].increment(by: by, exemplar: exemplar)
           end
 
-          def get(labels:)
-            @internal_store[labels]
+          def get(labels:, with_exemplars: false)
+            if with_exemplars
+              @internal_store[labels]
+            else
+              @internal_store[labels].value
+            end
           end
 
-          def all_values
-            @internal_store.dup
+          def all_values(with_exemplars: false)
+            if with_exemplars
+              @internal_store.dup
+            else
+              # this mess is just for backwards compatibility
+              output = Hash.new { |hash, key| hash[key] = 0.0 }
+              @internal_store.keys.each do |k|
+                output[k] = @internal_store[k].value
+              end
+
+              output
+            end
           end
         end
 
diff --git a/lib/prometheus/client/data_stores/synchronized.rb b/lib/prometheus/client/data_stores/synchronized.rb
index d0a74608..450cb118 100644
--- a/lib/prometheus/client/data_stores/synchronized.rb
+++ b/lib/prometheus/client/data_stores/synchronized.rb
@@ -1,3 +1,8 @@
+# no idea why this is reuired but giving up for now
+require 'prometheus/client/exemplar'
+require 'prometheus/client/exemplar_collection'
+require 'prometheus/client/value_with_exemplars'
+
 module Prometheus
   module Client
     module DataStores
@@ -24,7 +29,7 @@ def validate_metric_settings(metric_settings:)
 
         class MetricStore
           def initialize
-            @internal_store = Hash.new { |hash, key| hash[key] = 0.0 }
+            @internal_store = Hash.new { |hash, key| hash[key] = Prometheus::Client::ValueWithExemplars.new }
             @lock = Monitor.new
           end
 
@@ -32,26 +37,42 @@ def synchronize
             @lock.synchronize { yield }
           end
 
-          def set(labels:, val:)
+          def set(labels:, val:, exemplar: nil)
             synchronize do
-              @internal_store[labels] = val.to_f
+              @internal_store[labels].set(value: val, exemplar: exemplar)
             end
           end
 
-          def increment(labels:, by: 1)
+          def increment(labels:, by: 1, exemplar: nil)
             synchronize do
-              @internal_store[labels] += by
+              @internal_store[labels].increment(by: by, exemplar: exemplar)
             end
           end
 
-          def get(labels:)
+          def get(labels:, with_exemplars: false)
             synchronize do
-              @internal_store[labels]
+              if with_exemplars
+                @internal_store[labels]
+              else
+                @internal_store[labels].value
+              end
             end
           end
 
-          def all_values
-            synchronize { @internal_store.dup }
+          def all_values(with_exemplars: false)
+            synchronize do
+              if with_exemplars
+                @internal_store.dup
+              else
+                # this mess is just for backwards compatibility
+                output = Hash.new { |hash, key| hash[key] = 0.0 }
+                @internal_store.keys.each do |k|
+                  output[k] = @internal_store[k].value
+                end
+
+                output
+              end
+            end
           end
         end
 
diff --git a/lib/prometheus/client/exemplar.rb b/lib/prometheus/client/exemplar.rb
new file mode 100644
index 00000000..0d6138ec
--- /dev/null
+++ b/lib/prometheus/client/exemplar.rb
@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+
+    # Store a snapshot of metric data including an extra set of kv pairs for a specific moment in
+    # time and specific moment of code execution.
+    #
+    # Value is expected to be set after the exemplar is initialized.  Exemplars without a value will
+    # not be exported.
+    class Exemplar
+      # The kv pairs that make up the unique information in the exemplar.
+      #
+      # We generally store trace ids here
+      attr_reader :labels
+
+      # The time the exemplar was recorded
+      attr_reader :timestamp
+
+      # The value of the metric at the time the exemplar was recorded
+      attr_writer :value
+      attr_reader :value
+
+      def initialize(labels: {}, timestamp: nil)
+        @labels = labels
+        @timestamp = timestamp || Time.now.to_i
+      end
+
+      def empty?
+        value.nil?
+      end
+    end
+  end
+end
diff --git a/lib/prometheus/client/exemplar_collection.rb b/lib/prometheus/client/exemplar_collection.rb
new file mode 100644
index 00000000..5df49250
--- /dev/null
+++ b/lib/prometheus/client/exemplar_collection.rb
@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    class ExemplarCollection
+      include Enumerable
+
+      # store the exemplars attached to a metric + label set
+      def initialize
+        @collection = {}
+
+        # theoretical way to avoid causing a major memory leak
+        #
+        # This could store two minutes of requests with 2 requests per second with these settings.
+        # I am not clear on the situation where this wouldn't be enough but I am sure I will find it
+        @max_timestamps = 120
+        @max_exemplars = 240
+        @exemplar_count = 0
+      end
+
+      def add(exemplar)
+        cleanup_if_necessary
+        @collection[exemplar.timestamp] ||= []
+        @collection[exemplar.timestamp] << exemplar
+
+        exemplar
+      end
+
+      def most_recent
+        @collection[last_key]&.last
+      end
+
+      def last
+        most_recent
+      end
+
+      def each
+        @collection.keys.sort.each do |key|
+          @collection[key].each do |exemplar|
+            yield(exemplar)
+          end
+        end
+      end
+
+      def size
+        @exemplar_count
+      end
+
+      private
+      
+      def cleanup_if_necessary
+        if @exemplar_count >= @max_exemplars || @collection.keys.size >= @max_timestamps
+          @exemplar_count -= @collection.delete(first_key)&.size
+        end
+
+        @exemplar_count += 1
+      end
+      
+      def first_key
+        @collection.keys.sort&.first
+      end
+
+      def last_key
+        @collection.keys.sort&.last
+      end
+    end
+  end
+end
diff --git a/lib/prometheus/client/formats/open_metrics.rb b/lib/prometheus/client/formats/open_metrics.rb
new file mode 100644
index 00000000..29094e96
--- /dev/null
+++ b/lib/prometheus/client/formats/open_metrics.rb
@@ -0,0 +1,180 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    module Formats
+      module OpenMetrics
+        # used by the middleware to determine if this format works for the request
+        MEDIA_TYPE   = 'application/openmetrics-text'.freeze
+        VERSION      = '1.0.0'.freeze
+        CONTENT_TYPE = "#{MEDIA_TYPE}; version=#{VERSION}; charset=utf-8".freeze
+        DELIMITER = "\n".freeze
+        EOF = "# EOF\n"
+
+        # public interface to generate out the /metrics payload
+        def self.marshal(registry)
+          lines = []
+
+          registry.metrics.each do |metric|
+            # generate metric and put it in lines
+            lines << Writer.new(metric).write
+          end
+
+          (lines.flatten.compact << EOF).join(DELIMITER)
+        end
+
+        class Writer
+          attr_reader :metric
+          def initialize(metric)
+            @metric = metric
+          end
+
+          def name
+            metric.name.to_s
+          end
+
+          def docstring
+            metric.docstring
+          end
+
+          def unit
+            metric&.unit || nil
+          end
+
+          # the spec has a weird conversion with hard coded constants
+          # I am not sure if they are necessary
+          # for example counter converts to %d99.111.117.110.116.101.114 which really looks like
+          # character encodings for the word counter
+          def type
+            metric.type.to_sym
+          end
+
+          def metrics_to_a
+            # special case for summaries
+            # special case for histograms
+            # maybe start with gauges/counters because they are easy
+            output = []
+
+            if type == :histogram
+              output << histogram
+            elsif type == :summary
+              output << summary
+            elsif type == :counter
+              output << counter
+            else # if [:gauge].include?(type)
+              metric.values(with_exemplars: true).collect do |label_set, value_with_exemplars|
+                output << metric_line(name, label_set, value_with_exemplars.value, value_with_exemplars.most_recent_exemplar)
+              end
+            end
+
+            output.flatten
+          end
+
+          def histogram
+            output = []
+
+            metric.values.collect do |label_set, value|
+              bucket = "#{name}_bucket"
+              value.each do |quantile, v|
+                next if quantile == "sum"
+                output << metric_line(bucket, label_set.merge(le: quantile), v)
+              end
+
+              output << metric_line("#{name}_sum", label_set, value["sum"])
+              output << metric_line("#{name}_count", label_set, value["+Inf"])
+              # created is dependent on the exemplar working
+              # output << metric_line("#{name}_created", label_set, created)
+            end
+
+            output
+          end
+
+          def summary
+            output = []
+
+            metric.values.collect do |label_set, vwe|
+              output << metric_line("#{name}_sum", label_set, vwe.value["sum"], vwe.most_recent_exemplar)
+              output << metric_line("#{name}_count", label_set, vwe.value["count"], vwe.most_recent_exemplar)
+              output << metric_line("#{name}_created", label_set, vwe.created)
+            end
+
+            output
+          end
+
+          def counter
+            output = []
+            total_value = 0
+            most_recent_total_exemplar = Exemplar.new(labels: {}, timestamp: 0)
+
+            metric.values(with_exemplars: true).collect do |label_set, value_with_exemplars|
+              value = value_with_exemplars.value
+              exemplar = value_with_exemplars.most_recent_exemplar
+              created = value_with_exemplars.created
+
+              # hack in support to remove _total from all of our counters because _total is now a
+              # reserved word
+              metric_name = name.gsub(/_total$/, "")
+
+              output << metric_line(name, label_set, value, exemplar)
+              output << metric_line("#{name}_created", label_set, created)
+
+              total_value += value
+              most_recent_total_exemplar = exemplar if exemplar && exemplar.timestamp > most_recent_total_exemplar.timestamp
+            end
+            
+            # assume any exemplar fits here (regardless of labels) as long as it is the most recent
+            output << metric_line("#{name}_total", {}, total_value, most_recent_total_exemplar)
+
+            output
+          end
+
+          def metric_line(name, label_set, value, exemplar = nil)
+            output = "#{name}#{labels(label_set)} #{value}"
+            output += " #{timestamp}" if timestamp
+            output += " # #{labels(exemplar.labels)} #{exemplar.value} #{exemplar.timestamp}" if exemplar && !exemplar.empty?
+
+            output
+          end
+
+          def timestamp
+            # not implemented yet
+            return nil
+          end
+
+          def labels(set)
+            return if set.empty?
+
+            output = []
+
+            set.each do |key, value|
+              output << "#{key}=\"#{escape(value, :label)}\""
+            end
+
+            "{#{output.join(",")}}"
+          end
+
+          # to be rewritten
+          REGEX   = { doc: /[\n\\]/, label: /[\n\\"]/ }.freeze
+          REPLACE = { "\n" => '\n', '\\' => '\\\\', '"' => '\"' }.freeze
+          def escape(string, format = :doc)
+            string.to_s.gsub(REGEX[format], REPLACE)
+          end
+
+          def description
+            output = []
+            output << "# TYPE #{name} #{type}"
+            output << "# UNIT #{name} #{unit}" if unit
+            output << "# HELP #{name} #{escape(docstring, :doc)}"
+
+            output
+          end
+
+          def write
+            (description + metrics_to_a).flatten.join(Prometheus::Client::Formats::OpenMetrics::DELIMITER)
+          end
+
+        end
+      end
+    end
+  end
+end
diff --git a/lib/prometheus/client/formats/text.rb b/lib/prometheus/client/formats/text.rb
index b735389c..40ff092b 100644
--- a/lib/prometheus/client/formats/text.rb
+++ b/lib/prometheus/client/formats/text.rb
@@ -6,7 +6,7 @@ module Formats
       # Text format is human readable mainly used for manual inspection.
       module Text
         MEDIA_TYPE   = 'text/plain'.freeze
-        VERSION      = '0.0.4'.freeze
+        VERSION      = '0.0.1'.freeze
         CONTENT_TYPE = "#{MEDIA_TYPE}; version=#{VERSION}".freeze
 
         METRIC_LINE = '%s%s %s'.freeze
@@ -51,8 +51,8 @@ def representation(metric, label_set, value, &block)
 
           def summary(name, set, value)
             l = labels(set)
-            yield metric("#{name}_sum", l, value["sum"])
-            yield metric("#{name}_count", l, value["count"])
+            yield metric("#{name}_sum", l, value.value["sum"])
+            yield metric("#{name}_count", l, value.value["count"])
           end
 
           def histogram(name, set, value)
diff --git a/lib/prometheus/client/gauge.rb b/lib/prometheus/client/gauge.rb
index e0f76521..f7bde67d 100644
--- a/lib/prometheus/client/gauge.rb
+++ b/lib/prometheus/client/gauge.rb
@@ -12,26 +12,26 @@ def type
       end
 
       # Sets the value for the given label set
-      def set(value, labels: {})
+      def set(value, labels: {}, exemplar: nil)
         unless value.is_a?(Numeric)
           raise ArgumentError, 'value must be a number'
         end
 
-        @store.set(labels: label_set_for(labels), val: value)
+        @store.set(labels: label_set_for(labels), val: value, exemplar: exemplar)
       end
 
       # Increments Gauge value by 1 or adds the given value to the Gauge.
       # (The value can be negative, resulting in a decrease of the Gauge.)
-      def increment(by: 1, labels: {})
+      def increment(by: 1, labels: {}, exemplar: nil)
         label_set = label_set_for(labels)
-        @store.increment(labels: label_set, by: by)
+        @store.increment(labels: label_set, by: by, exemplar: exemplar)
       end
 
       # Decrements Gauge value by 1 or subtracts the given value from the Gauge.
       # (The value can be negative, resulting in a increase of the Gauge.)
-      def decrement(by: 1, labels: {})
+      def decrement(by: 1, labels: {}, exemplar: nil)
         label_set = label_set_for(labels)
-        @store.increment(labels: label_set, by: -by)
+        @store.increment(labels: label_set, by: -by, exemplar: exemplar)
       end
     end
   end
diff --git a/lib/prometheus/client/histogram.rb b/lib/prometheus/client/histogram.rb
index 6963f673..ff142a52 100644
--- a/lib/prometheus/client/histogram.rb
+++ b/lib/prometheus/client/histogram.rb
@@ -66,7 +66,7 @@ def type
       # in the sum of observations. See
       # https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations
       # for details.
-      def observe(value, labels: {})
+      def observe(value, labels: {}, exemplar: nil)
         bucket = buckets.find {|upper_limit| upper_limit >= value  }
         bucket = "+Inf" if bucket.nil?
 
@@ -79,8 +79,8 @@ def observe(value, labels: {})
         sum_label_set[:le] = "sum"
 
         @store.synchronize do
-          @store.increment(labels: bucket_label_set, by: 1)
-          @store.increment(labels: sum_label_set, by: value)
+          @store.increment(labels: bucket_label_set, by: 1, exemplar: exemplar)
+          @store.increment(labels: sum_label_set, by: value, exemplar: exemplar)
         end
       end
 
diff --git a/lib/prometheus/client/metric.rb b/lib/prometheus/client/metric.rb
index 2094ed53..bfb9fc9c 100644
--- a/lib/prometheus/client/metric.rb
+++ b/lib/prometheus/client/metric.rb
@@ -2,12 +2,14 @@
 
 require 'thread'
 require 'prometheus/client/label_set_validator'
+require 'prometheus/client/exemplar'
+require 'prometheus/client/exemplar_collection'
 
 module Prometheus
   module Client
     # Metric
     class Metric
-      attr_reader :name, :docstring, :labels, :preset_labels
+      attr_reader :name, :docstring, :labels, :preset_labels, :unit
 
       def initialize(name,
                      docstring:,
@@ -28,6 +30,7 @@ def initialize(name,
         @name = name
         @docstring = docstring
         @preset_labels = stringify_values(preset_labels)
+        @unit = nil # not fully supported yet
 
         @all_labels_preset = false
         if preset_labels.keys.length == labels.length
@@ -76,8 +79,8 @@ def init_label_set(labels)
       end
 
       # Returns all label sets with their values
-      def values
-        @store.all_values
+      def values(with_exemplars: false)
+        @store.all_values(with_exemplars: with_exemplars)
       end
 
       private
diff --git a/lib/prometheus/client/summary.rb b/lib/prometheus/client/summary.rb
index dff2f360..3b51b826 100644
--- a/lib/prometheus/client/summary.rb
+++ b/lib/prometheus/client/summary.rb
@@ -17,12 +17,12 @@ def type
       # in the sum of observations. See
       # https://prometheus.io/docs/practices/histograms/#count-and-sum-of-observations
       # for details.
-      def observe(value, labels: {})
+      def observe(value, labels: {}, exemplar: nil)
         base_label_set = label_set_for(labels)
 
         @store.synchronize do
-          @store.increment(labels: base_label_set.merge(quantile: "count"), by: 1)
-          @store.increment(labels: base_label_set.merge(quantile: "sum"), by: value)
+          @store.increment(labels: base_label_set.merge(quantile: "count"), by: 1, exemplar: exemplar)
+          @store.increment(labels: base_label_set.merge(quantile: "sum"), by: value, exemplar: exemplar)
         end
       end
 
@@ -40,13 +40,36 @@ def get(labels: {})
       end
 
       # Returns all label sets with their values expressed as hashes with their sum/count
+      #
+      # Converts from
+      # {
+      #   {<labels>, :quantile=>"count"} => <value>,
+      #   {<labels>, :quantile=>"sum"} => <value>
+      # }
+      # to
+      # {
+      #   <labels>: {count: <value>, sum: <value>}
+      # }
+      #
+      # This isn't going to work long term because it isn't possible to differentiate between
+      # exemplars whose value is based on the count and exemplars whose value is based on the sum.
+      # For now, it is random/unusable.
       def values
-        values = @store.all_values
+        values = @store.all_values(with_exemplars: true)
 
-        values.each_with_object({}) do |(label_set, v), acc|
+        values.each_with_object({}) do |(label_set, value_with_exemplars), acc|
           actual_label_set = label_set.reject{|l| l == :quantile }
-          acc[actual_label_set] ||= { "count" => 0.0, "sum" => 0.0 }
-          acc[actual_label_set][label_set[:quantile]] = v
+
+          if acc.has_key? actual_label_set
+            acc[actual_label_set].value[label_set[:quantile]] = value_with_exemplars.value
+          else
+            new_vwe = ValueWithExemplars.new
+            value = { "count" => 0.0, "sum" => 0.0 }.merge({ label_set[:quantile] => value_with_exemplars.value })
+            new_vwe.value = value
+            new_vwe.exemplars = value_with_exemplars.exemplars # only copy over the exemplars once because both quantiles have the same exemplars
+
+            acc[actual_label_set] = new_vwe
+          end
         end
       end
 
diff --git a/lib/prometheus/client/value_with_exemplars.rb b/lib/prometheus/client/value_with_exemplars.rb
new file mode 100644
index 00000000..ca7e6b3b
--- /dev/null
+++ b/lib/prometheus/client/value_with_exemplars.rb
@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    # stores a value for a label permutation on a metric along with all the exemplars that match the
+    # labels.
+    #
+    # The labels are actually stored somewhere else.  Maybe we could duplicate them here?
+    #
+    # no idea how this is going to work with histograms
+    class ValueWithExemplars
+      # changed from reader to accessor to make object setup easier for summaries
+      attr_accessor :value, :exemplars, :created
+
+      def initialize
+        @exemplars = ExemplarCollection.new
+        @value = 0.0
+
+        # slightly confused on the spec for this one
+        # One reading is that the created timestamp is on a per label set/metricpoint basis, not per
+        # metric.  I also wrote a parallel change that adds the created to the constructor in
+        # metric.rb and decided to remove it based on the spec interpretation.
+        #
+        # Floating point time is used to match the spec examples
+        @created = Time.now.to_f
+      end
+
+      def most_recent_exemplar
+        @exemplars.most_recent
+      end
+
+      def set(value:, exemplar: nil)
+        @value = value.to_f
+        if exemplar
+          exemplar.value = @value # not convinced this line goes in this file
+          @exemplars.add(exemplar)
+        end
+
+        @value
+      end
+
+      def increment(by: 1, exemplar: nil)
+        @value += by
+        if exemplar
+          exemplar.value = @value # not convinced this line goes in this file
+          @exemplars.add(exemplar)
+        end
+
+        @value
+      end
+    end
+  end
+end
diff --git a/lib/prometheus/middleware/exporter.rb b/lib/prometheus/middleware/exporter.rb
index a377525c..a9c0bda9 100644
--- a/lib/prometheus/middleware/exporter.rb
+++ b/lib/prometheus/middleware/exporter.rb
@@ -2,6 +2,7 @@
 
 require 'prometheus/client'
 require 'prometheus/client/formats/text'
+require 'prometheus/client/formats/open_metrics'
 
 module Prometheus
   module Middleware
@@ -14,8 +15,10 @@ module Middleware
     class Exporter
       attr_reader :app, :registry, :path
 
-      FORMATS  = [Client::Formats::Text].freeze
-      FALLBACK = Client::Formats::Text
+      # this file does not support multiple formats
+      # I am officially giving up
+      FORMATS  = [Client::Formats::OpenMetrics].freeze
+      FALLBACK = Client::Formats::OpenMetrics
 
       def initialize(app, options = {})
         @app = app
@@ -77,7 +80,7 @@ def not_acceptable(formats)
         [
           406,
           { 'content-type' => 'text/plain' },
-          ["Supported media types: #{types.join(', ')}"],
+          ["Supported media types: #{types.uniq.join(', ')}"],
         ]
       end
 
diff --git a/prometheus-client.gemspec b/prometheus-client.gemspec
index 6083a16e..11bec07f 100644
--- a/prometheus-client.gemspec
+++ b/prometheus-client.gemspec
@@ -17,4 +17,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'benchmark-ips'
   s.add_development_dependency 'concurrent-ruby'
+  s.add_development_dependency 'pry-byebug'
 end
diff --git a/spec/prometheus/client/exemplar_collection_spec.rb b/spec/prometheus/client/exemplar_collection_spec.rb
new file mode 100644
index 00000000..17b58c4f
--- /dev/null
+++ b/spec/prometheus/client/exemplar_collection_spec.rb
@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require 'prometheus/client/exemplar'
+require 'prometheus/client/exemplar_collection'
+
+describe Prometheus::Client::ExemplarCollection do
+  describe "add" do
+    it "adds an exemplar" do
+      collection = described_class.new
+
+      exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"}, timestamp: 1)
+      collection.add(exemplar)
+
+      expect(collection.first).to eq(exemplar)
+    end
+
+    it "cleans up if necessary" do
+      collection = described_class.new
+
+      120.times do |index|
+        exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"}, timestamp: index)
+        collection.add(exemplar)
+      end
+
+      expect(collection.size).to eq(120)
+
+      exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"}, timestamp: 1000)
+      collection.add(exemplar)
+
+      expect(collection.size).to eq(120)
+      expect(collection.most_recent.timestamp).to eq(1000)
+    end
+  end
+
+  describe "most_recent" do
+    it "returns the most recent exemplar by timestamp" do
+      collection = described_class.new
+
+      exemplar_1 = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"}, timestamp: 10)
+      collection.add(exemplar_1)
+
+      exemplar_2 = Prometheus::Client::Exemplar.new(labels: {hotdogs: "bad"}, timestamp: 5)
+      collection.add(exemplar_2)
+
+      expect(collection.most_recent).to eq(exemplar_1)
+    end
+
+    it "returns the most recently written exemplar if there is a timestamp tie" do
+      collection = described_class.new
+
+      exemplar_1 = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"}, timestamp: 1)
+      collection.add(exemplar_1)
+
+      exemplar_2 = Prometheus::Client::Exemplar.new(labels: {hotdogs: "bad"}, timestamp: 1)
+      collection.add(exemplar_2)
+
+      expect(collection.most_recent).to eq(exemplar_2)
+    end
+  end
+end
diff --git a/spec/prometheus/client/exemplar_spec.rb b/spec/prometheus/client/exemplar_spec.rb
new file mode 100644
index 00000000..b3c48e01
--- /dev/null
+++ b/spec/prometheus/client/exemplar_spec.rb
@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require 'prometheus/client/exemplar'
+
+describe Prometheus::Client::Exemplar do
+  it "sets default labels" do
+    e = described_class.new
+
+    expect(e.labels).to eq({})
+  end
+
+  it "sets a default timestamp" do
+    e = described_class.new
+
+    expect(e.timestamp).to be <= Time.now.to_i
+  end
+
+  it "is empty" do
+    e = described_class.new
+
+    expect(e).to be_empty
+
+    e.value = 5
+    expect(e).not_to be_empty
+  end
+end
diff --git a/spec/prometheus/client/formats/open_metrics_spec.rb b/spec/prometheus/client/formats/open_metrics_spec.rb
new file mode 100644
index 00000000..5431970d
--- /dev/null
+++ b/spec/prometheus/client/formats/open_metrics_spec.rb
@@ -0,0 +1,268 @@
+# encoding: UTF-8
+
+require 'prometheus/client'
+require 'prometheus/client/registry'
+require 'prometheus/client/formats/open_metrics'
+require "prometheus/client/value_with_exemplars"
+require "prometheus/client/exemplar_collection"
+require "prometheus/client/exemplar"
+
+describe Prometheus::Client::Formats::OpenMetrics do
+  # Reset the data store
+  before do
+    Prometheus::Client.config.data_store = Prometheus::Client::DataStores::Synchronized.new
+  end
+
+  let(:registry) { Prometheus::Client::Registry.new }
+
+  describe "metric writers" do
+    it "fully supports unit including comment string and forcing a metric name change based on the unit name"
+
+    describe "counter" do
+      let(:counter_metric) do
+        counter_metric = registry.counter(:counter_metric,
+                               docstring: 'foo description',
+                               labels: [:umlauts, :utf, :code],
+                               preset_labels: {umlauts: 'Björn', utf: '佖佥'})
+        counter_metric.increment(labels: { code: 'red'}, by: 42)
+        counter_metric.increment(labels: { code: 'green'}, by: 3.14E42)
+        counter_metric.increment(labels: { code: 'blue'}, by: 1.23e-45)
+
+        counter_metric
+      end
+
+      it "generates a metric description" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(counter_metric)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("# TYPE counter_metric counter")
+        # expect(lines).to include("# UNIT counter_metric hotdogs")
+        expect(lines).to include("# HELP counter_metric foo description")
+      end
+
+      it "generates a metric without exemplars" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(counter_metric)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("counter_metric{umlauts=\"Björn\",utf=\"佖佥\",code=\"red\"} 42.0")
+        expect(lines).to include("counter_metric{umlauts=\"Björn\",utf=\"佖佥\",code=\"green\"} 3.14e+42")
+        expect(lines).to include("counter_metric{umlauts=\"Björn\",utf=\"佖佥\",code=\"blue\"} 1.23e-45")
+      end
+      
+      let(:counter_with_exemplars) do
+        counter_with_exemplars = registry.counter(:counter_with_exemplars,
+                               docstring: 'foo description',
+                               labels: [:umlauts, :utf, :code],
+                               preset_labels: {umlauts: 'Björn', utf: '佖佥'})
+
+        counter_with_exemplars.increment(
+          labels: { code: 'red'},
+          by: 42,
+          exemplar: Prometheus::Client::Exemplar.new(labels: {trace_id: 12345}, timestamp: 1000)
+        )
+        counter_with_exemplars.increment(labels: { code: 'red'}, by: 1)
+        counter_with_exemplars.increment(
+          labels: { code: 'blue'},
+          by: 1000,
+          exemplar: Prometheus::Client::Exemplar.new(labels: {trace_id: 23456}, timestamp: 2000)
+        )
+
+        counter_with_exemplars
+      end
+
+      it "generates a metric with an exemplar" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(counter_with_exemplars)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("counter_with_exemplars{umlauts=\"Björn\",utf=\"佖佥\",code=\"red\"} 43.0 # {trace_id=\"12345\"} 42.0 1000")
+        expect(lines).to include("counter_with_exemplars{umlauts=\"Björn\",utf=\"佖佥\",code=\"blue\"} 1000.0 # {trace_id=\"23456\"} 1000.0 2000")
+      end
+
+      it "generates a total metric point with exemplar and without labels" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(counter_with_exemplars)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("counter_with_exemplars_total 1043.0 # {trace_id=\"23456\"} 1000.0 2000")
+      end
+
+      it "generates a created metric point without exemplar and with labels" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(counter_with_exemplars)
+
+        lines = writer.write.split("\n")
+
+        # this is hard to test
+        red_created = counter_with_exemplars.values(with_exemplars: true)[{:umlauts=>"Björn", :utf=>"佖佥", :code=>"red"}].created
+        expect(lines).to include("counter_with_exemplars_created{umlauts=\"Björn\",utf=\"佖佥\",code=\"red\"} #{red_created}")
+        blue_created = counter_with_exemplars.values(with_exemplars: true)[{:umlauts=>"Björn", :utf=>"佖佥", :code=>"blue"}].created
+        expect(lines).to include("counter_with_exemplars_created{umlauts=\"Björn\",utf=\"佖佥\",code=\"blue\"} #{blue_created}")
+      end
+
+      it "does not write an exemplar with no value"
+    end
+
+    describe "gauge" do
+      let :gauge_with_exemplar do
+        bar = registry.gauge(:gauge_with_exemplar,
+                             docstring: "bar description\nwith newline",
+                             labels: [:status, :code])
+        bar.set(15, labels: { status: 'success', code: 'pink'}, exemplar: Prometheus::Client::Exemplar.new(labels: {trace_id: 23456}, timestamp: 2000))
+        bar.set(17, labels: { status: 'success', code: 'pink'})
+
+        bar
+      end
+
+      it "generates a metric description" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(gauge_with_exemplar)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("# TYPE gauge_with_exemplar gauge")
+        # expect(lines).to include("# UNIT gauge_with_exemplar hotdogs")
+        expect(lines).to include("# HELP gauge_with_exemplar bar description\\nwith newline")
+      end
+
+      it "generates a metric without a timestamp" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(gauge_with_exemplar)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("gauge_with_exemplar{status=\"success\",code=\"pink\"} 17.0 # {trace_id=\"23456\"} 15.0 2000")
+      end
+    end
+
+    describe "histogram" do
+      let(:histogram_without_ts) do
+        xuq = registry.histogram(:histogram_without_ts,
+                                 docstring: 'xuq description',
+                                 labels: [:code],
+                                 preset_labels: {code: 'ah'},
+                                 buckets: [10, 20, 30])
+        xuq.observe(12)
+        xuq.observe(3.2)
+
+        xuq
+      end
+
+      it "generates a metric description" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(histogram_without_ts)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("# TYPE histogram_without_ts histogram")
+        # expect(lines).to include("# UNIT histogram_without_ts hotdogs")
+        expect(lines).to include("# HELP histogram_without_ts xuq description")
+      end
+
+      it "generates a metric without a timestamp" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(histogram_without_ts)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("histogram_without_ts_bucket{code=\"ah\",le=\"10\"} 1.0")
+        expect(lines).to include("histogram_without_ts_bucket{code=\"ah\",le=\"20\"} 2.0")
+        expect(lines).to include("histogram_without_ts_bucket{code=\"ah\",le=\"30\"} 2.0")
+        expect(lines).to include("histogram_without_ts_bucket{code=\"ah\",le=\"+Inf\"} 2.0")
+        expect(lines).to include("histogram_without_ts_sum{code=\"ah\"} 15.2")
+        expect(lines).to include("histogram_without_ts_count{code=\"ah\"} 2.0")
+      end
+      it "generates a metric with a timestamp" do
+        
+      end
+      it "generates a metric with an exemplar"
+
+      it "generates a metric with at least one bucket, sum, created, and count metric points"
+      it "generates a bucket with a +Inf threshold that counts all values"
+      it "generates cumulative buckets, a low value increments the count in all buckets with higher values"
+      it "generates a sum that equals the sum of all measured event values"
+      it "if there is a negative valued bucket, there should be no sum metric"
+      it "is not clear if we should print the bucket multiple times with different timestamps to expose multiple exemplars"
+      it "Bucket values MAY have exemplars.  It is up to us on which bucket gets which exemplar other than the exemplar falling within the bucket range.  Docs say exemplars SHOULD be put into the bucket with the highest value."
+    end
+
+    describe "summary" do
+      let(:summary_metric) do
+        summary_metric = registry.summary(:summary_metric,
+                                          docstring: 'qux description',
+                                          labels: [:for, :code],
+                                          preset_labels: { for: 'sake', code: '1' })
+        80.times { summary_metric.observe(0) }
+        summary_metric.observe(0, exemplar: Prometheus::Client::Exemplar.new(labels: {trace_id: 12345}, timestamp: 1000))
+        10.times { summary_metric.observe(0) }
+        summary_metric.observe(0, exemplar: Prometheus::Client::Exemplar.new(labels: {trace_id: 23456}, timestamp: 2000))
+        summary_metric.observe(1243.21)
+
+        summary_metric
+      end
+
+      it "generates a metric description" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(summary_metric)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("# TYPE summary_metric summary")
+        expect(lines).to include("# HELP summary_metric qux description")
+      end
+
+      it "generates metrics with exemplars" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(summary_metric)
+
+        lines = writer.write.split("\n")
+
+        expect(lines).to include("summary_metric_sum{for=\"sake\",code=\"1\"} 1243.21 # {trace_id=\"23456\"} 0.0 2000")
+        expect(lines).to include("summary_metric_count{for=\"sake\",code=\"1\"} 93.0 # {trace_id=\"23456\"} 0.0 2000")
+      end
+
+      it "generates _created metric point" do
+        writer = Prometheus::Client::Formats::OpenMetrics::Writer.new(summary_metric)
+
+        lines = writer.write.split("\n")
+
+        # can't test against the timestamp
+        expect(lines).to include(match /summary_metric_created{for="sake",code="1"}/)
+      end
+    end
+
+    # we don't support these types right now so I am punting for now
+
+    # describe "gaugehistogram" do
+    #   it "generates a metric description"
+    #   it "generates a metric without a timestamp"
+    #   it "generates a metric with a timestamp"
+    #   it "generates a metric with an exemplar"
+    # end
+
+    # describe "stateset" do
+    #   it "generates a metric description"
+    #   it "generates a metric without a timestamp"
+    #   it "generates a metric with a timestamp"
+    #   it "generates a metric with an exemplar"
+    #
+    #   it "A point of a StateSet metric MAY contain multiple states and MUST contain one boolean per State. States have a name which are Strings."
+    #   it "A StateSet Metric's LabelSet MUST NOT have a label name which is the same as the name of its MetricFamily."
+    #   it "If encoded as a StateSet, ENUMs MUST have exactly one Boolean which is true within a MetricPoint."
+    #   it "MetricFamilies of type StateSets MUST have an empty Unit string."
+    # end
+
+    # describe "info" do
+    #   it "generates a metric description"
+    #   it "generates a metric without a timestamp"
+    #   it "generates a metric with a timestamp"
+    #   it "generates a metric with an exemplar"
+    #
+    #   it "A MetricPoint of an Info Metric contains a LabelSet. An Info MetricPoint's LabelSet MUST NOT have a label name which is the same as the name of a label of the LabelSet of its Metric."
+    #   it "Info MAY be used to encode ENUMs whose values do not change over time, such as the type of a network interface."
+    #   it "MetricFamilies of type Info MUST have an empty Unit string."
+    # end
+
+    # describe "unknown" do
+    #   it "generates a metric description"
+    #   it "generates a metric without a timestamp"
+    #   it "generates a metric with a timestamp"
+    #   it "generates a metric with an exemplar"
+    # end
+  end
+end
diff --git a/spec/prometheus/client/summary_spec.rb b/spec/prometheus/client/summary_spec.rb
index ba02ad36..fb3c7e26 100644
--- a/spec/prometheus/client/summary_spec.rb
+++ b/spec/prometheus/client/summary_spec.rb
@@ -79,10 +79,8 @@
       summary.observe(3, labels: { status: 'bar' })
       summary.observe(5, labels: { status: 'foo' })
 
-      expect(summary.values).to eql(
-        { status: 'bar' } => { "count" => 1.0, "sum" => 3.0 },
-        { status: 'foo' } => { "count" => 1.0, "sum" => 5.0 },
-      )
+      expect(summary.values[{ status: 'bar' }].value).to eql({ "count" => 1.0, "sum" => 3.0 })
+      expect(summary.values[{ status: 'foo' }].value).to eql({ "count" => 1.0, "sum" => 5.0 })
     end
   end
 
@@ -96,18 +94,14 @@
         summary.init_label_set(status: 'bar')
         summary.init_label_set(status: 'foo')
 
-        expect(summary.values).to eql(
-          { status: 'bar' } => { "count" => 0.0, "sum" => 0.0 },
-          { status: 'foo' } => { "count" => 0.0, "sum" => 0.0 },
-        )
+        expect(summary.values[{ status: 'bar' }].value).to eql({ "count" => 0.0, "sum" => 0.0 })
+        expect(summary.values[{ status: 'foo' }].value).to eql({ "count" => 0.0, "sum" => 0.0 })
       end
     end
 
     context "without labels" do
       it 'automatically initializes the metric' do
-        expect(summary.values).to eql(
-          {} => { "count" => 0.0, "sum" => 0.0 },
-        )
+        expect(summary.values[{}].value).to eql({ "count" => 0.0, "sum" => 0.0 })
       end
     end
   end
diff --git a/spec/prometheus/client/value_with_exemplar_spec.rb b/spec/prometheus/client/value_with_exemplar_spec.rb
new file mode 100644
index 00000000..bcca8e6b
--- /dev/null
+++ b/spec/prometheus/client/value_with_exemplar_spec.rb
@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+require 'prometheus/client/exemplar'
+require 'prometheus/client/exemplar_collection'
+
+describe Prometheus::Client::ValueWithExemplars do
+  describe "set" do
+    it "updates the value as a float" do
+      vwe = described_class.new
+
+      vwe.set(value: 5)
+
+      expect(vwe.value).to eq(5.0)
+    end
+
+    it "stores an exemplar and updates its value" do
+      vwe = described_class.new
+
+      exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"})
+      vwe.set(value: 5, exemplar: exemplar)
+
+      expect(vwe.most_recent_exemplar.value).to eq(5.0)
+    end
+  end
+
+  describe "increment" do
+    it "updates the value as a float" do
+      vwe = described_class.new
+
+      vwe.set(value: 5)
+      exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"})
+      vwe.increment(by: 7, exemplar: exemplar)
+
+      expect(vwe.value).to eq(12.0)
+      expect(vwe.most_recent_exemplar.value).to eq(12.0)
+    end
+  end
+
+  describe "most_recent_exemplar" do
+    it "returns the most recent exemplar by timestamp" do
+      vwe = described_class.new
+
+      vwe.set(value: 5)
+      exemplar = Prometheus::Client::Exemplar.new(labels: {hotdogs: "great"})
+      vwe.increment(by: 7, exemplar: exemplar)
+      vwe.increment(by: 3)
+
+      expect(vwe.value).to eq(15.0)
+      expect(vwe.most_recent_exemplar.value).to eq(12.0)
+    end
+  end
+end
diff --git a/spec/prometheus/middleware/exporter_spec.rb b/spec/prometheus/middleware/exporter_spec.rb
index e8232fc5..0b5b5363 100644
--- a/spec/prometheus/middleware/exporter_spec.rb
+++ b/spec/prometheus/middleware/exporter_spec.rb
@@ -26,7 +26,9 @@
   end
 
   context 'when requesting /metrics' do
-    text = Prometheus::Client::Formats::Text
+    # I am pretty annoyed at this hard coded format right now
+    # it should match the list of formats in the exporter and loop over the available ones
+    text = Prometheus::Client::Formats::OpenMetrics
 
     shared_examples 'ok' do |headers, fmt|
       it "responds with 200 OK and content-type #{fmt::CONTENT_TYPE}" do
@@ -42,7 +44,7 @@
 
     shared_examples 'not acceptable' do |headers|
       it 'responds with 406 Not Acceptable' do
-        message = 'Supported media types: text/plain'
+        message = 'Supported media types: application/openmetrics-text'
 
         get '/metrics', nil, headers
 
@@ -64,27 +66,29 @@
       include_examples 'not acceptable', 'HTTP_ACCEPT' => 'application/json'
     end
 
-    context 'when client requests text/plain' do
-      include_examples 'ok', { 'HTTP_ACCEPT' => 'text/plain' }, text
-    end
-
-    context 'when client uses different white spaces in Accept header' do
-      accept = 'text/plain;q=1.0  ; version=0.0.4'
-
-      include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
-    end
-
-    context 'when client does not include quality attribute' do
-      accept = 'application/json;q=0.5, text/plain'
-
-      include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
-    end
-
-    context 'when client accepts some unknown formats' do
-      accept = 'text/plain;q=0.3, proto/buf;q=0.7'
-
-      include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
-    end
+    # the openmetrics type does not accept text plain
+    # not sure if this is good or bad
+    # context 'when client requests text/plain' do
+    #   include_examples 'ok', { 'HTTP_ACCEPT' => 'text/plain' }, text
+    # end
+    #
+    # context 'when client uses different white spaces in Accept header' do
+    #   accept = 'text/plain;q=1.0  ; version=0.0.1' # why is this version hard coded?
+    #
+    #   include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
+    # end
+    #
+    # context 'when client does not include quality attribute' do
+    #   accept = 'application/json;q=0.5, text/plain'
+    #
+    #   include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
+    # end
+    #
+    # context 'when client accepts some unknown formats' do
+    #   accept = 'text/plain;q=0.3, proto/buf;q=0.7'
+    #
+    #   include_examples 'ok', { 'HTTP_ACCEPT' => accept }, text
+    # end
 
     context 'when client accepts only unknown formats' do
       accept = 'fancy/woo;q=0.3, proto/buf;q=0.7'