prometheus-client-mmap 0.7.0.beta8 → 0.7.0.beta9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 994fda67c8a970a53d796534315b82fd06f130c4
-  data.tar.gz: f9c0d71024d0f8f31e5578d063e78e1e784a4496
+  metadata.gz: 24351728cd7ccff16974ea7cf72a781f3b393831
+  data.tar.gz: aba591bd2540b26541949b3536a2b5fbc2850e72
 SHA512:
-  metadata.gz: e2a9d9727c6b7b29b14a7edcd38f1a4d1ef93be325ec0018c1f66811683f79d8f84e3c8333fda88260b6bb6f18003cc6a77256b1184a9e75c67cb6bfe1c2e69c
-  data.tar.gz: f71da51891d436487fbfb854a1bd65d79c4e471f37ce8f4e7043333e1719620277d762bac16960eb9aa354b4690f69150a6db0e4a29cb620cf6c86d70ecf7d57
+  metadata.gz: 5a6d7c3669a14ff150f3a7d79c119db34ed7a30404a6e69f0c6183e8c50b53325f6147fad8bbf5efd55137d00eef3c6e4c89b60c54e4dad8618753edc69bf06b
+  data.tar.gz: ff9e4880b4847076b887d5c2ee07fe09fefb88d0806b840d6a65f21a8d4e1c3aca05e07ca94561ec97bf79f6450a95f4129a48c1eb9cdf982ac898797d4101a4

data/lib/prometheus/client/configuration.rb

@@ -0,0 +1,18 @@
+require 'prometheus/client/registry'
+require 'prometheus/client/mmaped_value'
+require 'logger'
+
+module Prometheus
+  module Client
+    class Configuration
+      attr_accessor :value_class, :multiprocess_files_dir, :initial_mmap_file_size, :logger
+
+      def initialize
+        @value_class = ::Prometheus::Client::MmapedValue
+        @multiprocess_files_dir = ENV['prometheus_multiproc_dir']
+        @initial_mmap_file_size = 4 * 1024
+        @logger = Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/prometheus/client/counter.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
 require 'prometheus/client/metric'
-require 'prometheus/client/valuetype'
 
 module Prometheus
   module Client
@@ -21,7 +20,7 @@ module Prometheus
       private
 
       def default(labels)
-        ValueClass.new(type, @name, @name, labels)
+        value_object(type, @name, @name, labels)
       end
     end
   end

data/lib/prometheus/client/formats/text.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require 'prometheus/client/valuetype'
+require 'prometheus/client/uses_value_type'
 
 module Prometheus
   module Client
@@ -38,32 +36,8 @@ module Prometheus
           (lines << nil).join(DELIMITER)
         end
 
-        def self.marshal_multiprocess(path=Prometheus::Client::Multiprocdir)
-          metrics = {}
-          Dir.glob(File.join(path, "*.db")).each do |f|
-            parts = File.basename(f,'.db').split("_")
-            type = parts[0].to_sym
-            d = MmapedDict.new(f)
-            d.all_values.each do |key, value|
-              metric_name, name, labelnames, labelvalues = JSON.parse(key)
-              metric = metrics.fetch(metric_name, {
-                metric_name: metric_name,
-                help: 'Multiprocess metric',
-                type: type,
-                samples: [],
-              })
-              if type == :gauge
-                pid = parts[2]
-                metric[:multiprocess_mode] = parts[1]
-                metric[:samples] += [[name, labelnames.zip(labelvalues) + [['pid', pid]], value]]
-              else
-                # The duplicates and labels are fixed in the next for.
-                metric[:samples] += [[name, labelnames.zip(labelvalues), value]]
-              end
-              metrics[metric_name] = metric
-            end
-            d.close
-          end
+        def self.marshal_multiprocess(path = Prometheus::Client.configuration.multiprocess_files_dir)
+          metrics = load_metrics(path)
 
           metrics.each_value do |metric|
             samples = {}
@@ -118,6 +92,39 @@ module Prometheus
         class << self
           private
 
+          def load_metrics(path)
+            metrics = {}
+            Dir.glob(File.join(path, '*.db')).each do |f|
+              parts = File.basename(f, '.db').split('_')
+              type = parts[0].to_sym
+              d = MmapedDict.new(f)
+
+              begin
+                d.all_values.each do |key, value|
+                  metric_name, name, labelnames, labelvalues = JSON.parse(key)
+                  metric = metrics.fetch(metric_name,
+                                         metric_name: metric_name,
+                                         help: 'Multiprocess metric',
+                                         type: type,
+                                         samples: []
+                  )
+                  if type == :gauge
+                    pid = parts[2]
+                    metric[:multiprocess_mode] = parts[1]
+                    metric[:samples] += [[name, labelnames.zip(labelvalues) + [['pid', pid]], value]]
+                  else
+                    # The duplicates and labels are fixed in the next for.
+                    metric[:samples] += [[name, labelnames.zip(labelvalues), value]]
+                  end
+                  metrics[metric_name] = metric
+                end
+              ensure
+                d.close
+              end
+            end
+            metrics
+          end
+
           def representation(metric, label_set, value, &block)
             set = metric.base_labels.merge(label_set)
 

data/lib/prometheus/client/gauge.rb

@@ -9,7 +9,7 @@ module Prometheus
     class Gauge < Metric
       def initialize(name, docstring, base_labels = {}, multiprocess_mode=:all)
         super(name, docstring, base_labels)
-        if ValueClass.multiprocess and ![:min, :max, :livesum, :liveall, :all].include?(multiprocess_mode)
+        if value_class.multiprocess and ![:min, :max, :livesum, :liveall, :all].include?(multiprocess_mode)
           raise ArgumentError, 'Invalid multiprocess mode: ' + multiprocess_mode
         end
         @multiprocess_mode = multiprocess_mode
@@ -20,7 +20,7 @@ module Prometheus
       end
 
       def default(labels)
-        ValueClass.new(type, @name, @name, labels, @multiprocess_mode)
+        value_object(type, @name, @name, labels, @multiprocess_mode)
       end
 
       # Sets the value for the given label set

data/lib/prometheus/client/histogram.rb

@@ -1,6 +1,5 @@
-# encoding: UTF-8
-
 require 'prometheus/client/metric'
+require 'prometheus/client/uses_value_type'
 
 module Prometheus
   module Client
@@ -10,15 +9,16 @@ module Prometheus
     class Histogram < Metric
       # Value represents the state of a Histogram at a given point.
       class Value < Hash
+        include UsesValueType
         attr_accessor :sum, :total
 
         def initialize(type, name, labels, buckets)
-          @sum = ValueClass.new(type, name, "#{name}_sum", labels)
+          @sum = value_object(type, name, "#{name}_sum", labels)
           # TODO: get rid of total and use +Inf bucket instead.
-          @total = ValueClass.new(type, name, "#{name}_count", labels)
+          @total = value_object(type, name, "#{name}_count", labels)
 
           buckets.each do |bucket|
-            self[bucket] = ValueClass.new(type, name, "#{name}_bucket", labels.merge({:le => bucket.to_s}))
+            self[bucket] = value_object(type, name, "#{name}_bucket", labels.merge({ :le => bucket.to_s }))
           end
         end
 

data/lib/prometheus/client/metric.rb

@@ -1,25 +1,24 @@
-# encoding: UTF-8
-
 require 'thread'
 require 'prometheus/client/label_set_validator'
-require 'prometheus/client/valuetype'
+require 'prometheus/client/uses_value_type'
 
 module Prometheus
   module Client
     # Metric
     class Metric
+      include UsesValueType
       attr_reader :name, :docstring, :base_labels
 
       def initialize(name, docstring, base_labels = {})
         @mutex = Mutex.new
-        case type
-        when :summary
-          @validator = LabelSetValidator.new(['quantile'])
-        when :histogram
-          @validator = LabelSetValidator.new(['le'])
-        else
-          @validator = LabelSetValidator.new
-        end
+        @validator = case type
+                       when :summary
+                         LabelSetValidator.new(['quantile'])
+                       when :histogram
+                         LabelSetValidator.new(['le'])
+                       else
+                         LabelSetValidator.new
+                     end
         @values = Hash.new { |hash, key| hash[key] = default(key) }
 
         validate_name(name)
@@ -50,7 +49,7 @@ module Prometheus
       private
 
       def default(labels)
-        ValueClass.new(type, @name, @name, labels)
+        value_object(type, @name, @name, labels)
       end
 
       def validate_name(name)

data/lib/prometheus/client/mmaped_dict.rb

@@ -0,0 +1,123 @@
+module Prometheus
+  module Client
+    class ParsingError < StandardError; end
+
+    # A dict of doubles, backed by an mmapped file.
+    #
+    # The file starts with a 4 byte int, indicating how much of it is used.
+    # Then 4 bytes of padding.
+    # There's then a number of entries, consisting of a 4 byte int which is the
+    # size of the next field, a utf-8 encoded string key, padding to an 8 byte
+    # alignment, and then a 8 byte float which is the value.
+    #
+    # TODO(julius): dealing with Mmap.new, truncate etc. errors?
+    class MmapedDict
+      MINIMUM_SIZE = 4.freeze
+      attr_reader :m, :capacity, :used, :positions
+
+      def initialize(filename)
+        @mutex = Mutex.new
+        @f = File.open(filename, 'a+b')
+        process_file_wrappe_error
+      end
+
+      # Yield (key, value, pos). No locking is performed.
+      def all_values
+        read_all_values.map { |k, v, p| [k, v] }
+      end
+
+      def read_value(key)
+        @mutex.synchronize do
+          init_value(key) unless @positions.has_key?(key)
+        end
+        pos = @positions[key]
+        # We assume that reading from an 8 byte aligned value is atomic.
+        @m[pos..pos+7].unpack('d')[0]
+      end
+
+      def write_value(key, value)
+        @mutex.synchronize do
+          init_value(key) unless @positions.has_key?(key)
+        end
+        pos = @positions[key]
+        # We assume that writing to an 8 byte aligned value is atomic.
+        @m[pos..pos+7] = [value].pack('d')
+      end
+
+      def close()
+        @m.munmap
+        @f.close
+      end
+
+      private
+
+      def process_file_wrappe_error
+        process_file
+      rescue StandardError => e
+        raise ParsingError.new("exception #{e} while processing metrics file #{@f.path}")
+      end
+
+      def process_file
+        if @f.size < MINIMUM_SIZE
+          @f.truncate(initial_mmap_file_size)
+        end
+        @f.truncate(initial_mmap_file_size)
+
+        @capacity = @f.size
+        @m = Mmap.new(@f.path, 'rw', Mmap::MAP_SHARED)
+        # @m.mlock # TODO: Why does this raise an error?
+
+        @positions = {}
+        @used = @m[0..3].unpack('l')[0]
+        if @used == 0
+          @used = 8
+          @m[0..3] = [@used].pack('l')
+        else
+          read_all_values.each do |key, _, pos|
+            @positions[key] = pos
+          end
+        end
+      end
+
+      def initial_mmap_file_size
+        Prometheus::Client.configuration.initial_mmap_file_size
+      end
+
+      # Initialize a value. Lock must be held by caller.
+      def init_value(key)
+        # Pad to be 8-byte aligned.
+        padded = key + (' ' * (8 - (key.length + 4) % 8))
+        value = [key.length, padded, 0.0].pack("lA#{padded.length}d")
+        while @used + value.length > @capacity
+          @capacity *= 2
+          @f.truncate(@capacity)
+          @m.unmap
+          @m = Mmap.new(@f.path, 'rw', Mmap::MAP_SHARED)
+        end
+        @m[@used..@used + value.length] = value
+
+        # Update how much space we've used.
+        @used += value.length
+        @m[0..3] = [@used].pack('l')
+        @positions[key] = @used - 8
+      end
+
+      # Yield (key, value, pos). No locking is performed.
+      def read_all_values
+        pos = 8
+        values = []
+        while pos < @used
+          encoded_len = @m[pos..-1].unpack('l')[0]
+          pos += 4
+          encoded = @m[pos..-1].unpack("A#{encoded_len}")[0]
+          padded_len = encoded_len + (8 - (encoded_len + 4) % 8)
+          pos += padded_len
+          value = @m[pos..-1].unpack('d')[0]
+          values << [encoded, value, pos]
+          pos += 8
+        end
+        values
+      end
+    end
+  end
+end

data/lib/prometheus/client/mmaped_value.rb

@@ -0,0 +1,80 @@
+require 'prometheus/client/mmaped_dict'
+require 'json'
+
+module Prometheus
+  module Client
+    # A float protected by a mutex backed by a per-process mmaped file.
+    class MmapedValue
+      @@files = {}
+      @@files_lock = Mutex.new
+      @@pid = Process.pid
+
+      def initialize(type, metric_name, name, labels, multiprocess_mode='')
+        file_prefix = type.to_s
+        if type == :gauge
+          file_prefix += '_' + multiprocess_mode.to_s
+        end
+
+        @@files_lock.synchronize do
+          unless @@files.has_key?(file_prefix)
+            filename = File.join(Prometheus::Client.configuration.multiprocess_files_dir, "#{file_prefix}_#{@@pid}.db")
+            @@files[file_prefix] = MmapedDict.new(filename)
+          end
+        end
+
+        @file = @@files[file_prefix]
+        labelnames = []
+        labelvalues = []
+        labels.each do |k, v|
+          labelnames << k
+          labelvalues << v
+        end
+
+        @key = [metric_name, name, labelnames, labelvalues].to_json
+        @value = read_value(@key)
+        @mutex = Mutex.new
+      end
+
+      def increment(amount=1)
+        @mutex.synchronize do
+          @value += amount
+          write_value(@key, @value)
+          @value
+        end
+      end
+
+      def set(value)
+        @mutex.synchronize do
+          @value = value
+          write_value(@key, @value)
+          @value
+        end
+      end
+
+      def get
+        @mutex.synchronize do
+          return @value
+        end
+      end
+
+      def self.multiprocess
+        true
+      end
+
+      private
+
+      def write_value(key, val)
+        @file.write_value(key, val)
+      rescue StandardError => e
+        Prometheus::Client.logger.warn("writing value to #{@file.path} failed with #{e}")
+      end
+
+      def read_value(key)
+        @file.read_value(key)
+      rescue StandardError => e
+        Prometheus::Client.logger.warn("readomg value from #{@file.path} failed with #{e}")
+      end
+    end
+  end
+end
+

data/lib/prometheus/client/rack/exporter.rb

@@ -11,7 +11,7 @@ module Prometheus
       class Exporter
         attr_reader :app, :registry, :path
 
-        FORMATS  = [Formats::Text].freeze
+        FORMATS = [Formats::Text].freeze
         FALLBACK = Formats::Text
 
         def initialize(app, options = {})
@@ -62,8 +62,11 @@ module Prometheus
         end
 
         def respond_with(format)
-          # For now we're only supporting mmapped ValueClass.
-          response = format.marshal_multiprocess
+          response = if Prometheus::Client.configuration.value_class.multiprocess
+                       format.marshal_multiprocess
+                     else
+                       format.marshal
+                     end
           [
             200,
             { 'Content-Type' => format::CONTENT_TYPE },

data/lib/prometheus/client/simple_value.rb

@@ -0,0 +1,28 @@
+require 'json'
+require 'mmap'
+
+module Prometheus
+  module Client
+    class SimpleValue
+      def initialize(type, metric_name, name, labels, value = 0)
+        @value = value
+      end
+
+      def set(value)
+        @value = value
+      end
+
+      def increment(by = 1)
+        @value += by
+      end
+
+      def get
+        @value
+      end
+
+      def self.multiprocess
+        false
+      end
+    end
+  end
+end

data/lib/prometheus/client/summary.rb

@@ -1,6 +1,5 @@
-# encoding: UTF-8
-
 require 'prometheus/client/metric'
+require 'prometheus/client/uses_value_type'
 
 module Prometheus
   module Client
@@ -11,16 +10,17 @@ module Prometheus
 
       # Value represents the state of a Summary at a given point.
       class Value < Hash
+        include UsesValueType
         attr_accessor :sum, :total
 
         def initialize(type, name, labels)
-          @sum = ValueClass.new(type, name, "#{name}_sum", labels)
-          @total = ValueClass.new(type, name, "#{name}_count", labels)
+          @sum = value_object(type, name, "#{name}_sum", labels)
+          @total = value_object(type, name, "#{name}_count", labels)
         end
 
         def observe(value)
           @sum.increment(value)
-          @total.increment()
+          @total.increment
         end
       end
 
@@ -37,6 +37,7 @@ module Prometheus
         label_set = label_set_for(labels)
         synchronize { @values[label_set].observe(value) }
       end
+
       alias add observe
       deprecate :add, :observe, 2016, 10
 

data/lib/prometheus/client/uses_value_type.rb

@@ -0,0 +1,19 @@
+require 'prometheus/client/simple_value'
+
+module Prometheus
+  module Client
+    # Module providing convenience methods for creating value_object
+    module UsesValueType
+      def value_class
+        Prometheus::Client.configuration.value_class
+      end
+
+      def value_object(type, metric_name, name, labels, *args)
+        value_class.new(type, metric_name, name, labels, *args)
+      rescue StandardError => e
+        Prometheus::Client.logger.info("error #{e} while creating instance of #{value_class} defaultig to SimpleValue")
+        Prometheus::Client::SimpleValue.new(type, metric_name, name, labels)
+      end
+    end
+  end
+end

data/lib/prometheus/client/version.rb

@@ -2,6 +2,6 @@
 
 module Prometheus
   module Client
-    VERSION = '0.7.0.beta8'
+    VERSION = '0.7.0.beta9'
   end
 end

data/lib/prometheus/client.rb

@@ -1,13 +1,28 @@
-# encoding: UTF-8
-
 require 'prometheus/client/registry'
+require 'prometheus/client/configuration'
 
 module Prometheus
   # Client is a ruby implementation for a Prometheus compatible client.
   module Client
-    # Returns a default registry object
-    def self.registry
-      @registry ||= Registry.new
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      # Returns a default registry object
+      def registry
+        @registry ||= Registry.new
+      end
+
+      def logger
+        configuration.logger
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client-mmap
 version: !ruby/object:Gem::Version
-  version: 0.7.0.beta8
+  version: 0.7.0.beta9
 platform: ruby
 authors:
 - Tobias Schmidt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-04 00:00:00.000000000 Z
+date: 2017-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mmap2
@@ -40,18 +40,22 @@ files:
 - README.md
 - lib/prometheus.rb
 - lib/prometheus/client.rb
+- lib/prometheus/client/configuration.rb
 - lib/prometheus/client/counter.rb
 - lib/prometheus/client/formats/text.rb
 - lib/prometheus/client/gauge.rb
 - lib/prometheus/client/histogram.rb
 - lib/prometheus/client/label_set_validator.rb
 - lib/prometheus/client/metric.rb
+- lib/prometheus/client/mmaped_dict.rb
+- lib/prometheus/client/mmaped_value.rb
 - lib/prometheus/client/push.rb
 - lib/prometheus/client/rack/collector.rb
 - lib/prometheus/client/rack/exporter.rb
 - lib/prometheus/client/registry.rb
+- lib/prometheus/client/simple_value.rb
 - lib/prometheus/client/summary.rb
-- lib/prometheus/client/valuetype.rb
+- lib/prometheus/client/uses_value_type.rb
 - lib/prometheus/client/version.rb
 homepage: https://gitlab.com/gitlab-org/prometheus-client-mmap
 licenses:

data/lib/prometheus/client/valuetype.rb

@@ -1,207 +0,0 @@
-# encoding: UTF-8
-
-require "json"
-require "mmap"
-
-module Prometheus
-  module Client
-    class SimpleValue
-      def initialize(type, metric_name, name, labels, value = 0)
-        @value = value
-      end
-
-      def set(value)
-        @value = value
-      end
-
-      def increment(by = 1)
-        @value += by
-      end
-
-      def get
-        @value
-      end
-
-      def self.multiprocess
-        false
-      end
-    end
-
-    # A float protected by a mutex backed by a per-process mmaped file.
-    class MmapedValue
-      @@files = {}
-      @@files_lock = Mutex.new
-      @@pid = Process.pid
-
-      def initialize(type, metric_name, name, labels, multiprocess_mode='')
-        @@pid = Process.pid
-        file_prefix = type.to_s
-        if type == :gauge
-          file_prefix += '_' +  multiprocess_mode.to_s
-        end
-
-        @@files_lock.synchronize do
-          if !@@files.has_key?(file_prefix)
-            filename = File.join(Prometheus::Client::Multiprocdir, "#{file_prefix}_#{@@pid}.db")
-            @@files[file_prefix] = MmapedDict.new(filename)
-          end
-        end
-
-        @file = @@files[file_prefix]
-        labelnames = []
-        labelvalues = []
-        labels.each do |k, v|
-          labelnames << k
-          labelvalues << v
-        end
-
-        @key = [metric_name, name, labelnames, labelvalues].to_json
-        @value = @file.read_value(@key)
-        @mutex = Mutex.new
-      end
-
-      def increment(amount=1)
-        @mutex.synchronize do
-          @value += amount
-          @file.write_value(@key, @value)
-        end
-      end
-
-      def set(value)
-        @mutex.synchronize do
-          @value = value
-          @file.write_value(@key, @value)
-        end
-      end
-
-      def get
-        @mutex.synchronize do
-          return @value
-        end
-      end
-
-      def self.multiprocess
-        true
-      end
-    end
-
-    # Should we enable multi-process mode?
-    # This needs to be chosen before the first metric is constructed,
-    # and as that may be in some arbitrary library the user/admin has
-    # no control over we use an enviroment variable.
-    if ENV.has_key?('prometheus_multiproc_dir')
-      Multiprocdir = ENV['prometheus_multiproc_dir']
-      ValueClass = MmapedValue
-    else
-      # Only support mmap values for now.
-      Multiprocdir = '/var/run/gitlab/unicorn'
-      ValueClass = MmapedValue
-    end
-  end
-end
-
-# A dict of doubles, backed by an mmapped file.
-#
-# The file starts with a 4 byte int, indicating how much of it is used.
-# Then 4 bytes of padding.
-# There's then a number of entries, consisting of a 4 byte int which is the
-# size of the next field, a utf-8 encoded string key, padding to an 8 byte
-# alignment, and then a 8 byte float which is the value.
-#
-# TODO(julius): dealing with Mmap.new, truncate etc. errors?
-class MmapedDict
-  @@INITIAL_MMAP_SIZE = 1024*1024
-
-  attr_reader :m, :capacity, :used, :positions
-
-  def initialize(filename)
-    @mutex = Mutex.new
-    @f = File.open(filename, 'a+b')
-    if @f.size == 0
-      @f.truncate(@@INITIAL_MMAP_SIZE)
-    end
-    @capacity = @f.size
-    @m = Mmap.new(filename, 'rw', Mmap::MAP_SHARED)
-    # @m.mlock # TODO: Why does this raise an error?
-
-    @positions = {}
-    @used = @m[0..3].unpack('l')[0]
-    if @used == 0
-      @used = 8
-      @m[0..3] = [@used].pack('l')
-    else
-      read_all_values.each do |key, _, pos|
-        @positions[key] = pos
-      end
-    end
-  end
-
-  # Yield (key, value, pos). No locking is performed.
-  def all_values
-    read_all_values.map { |k, v, p| [k, v] }
-  end
-
-  def read_value(key)
-    @mutex.synchronize do
-      if !@positions.has_key?(key)
-        init_value(key)
-      end
-    end
-    pos = @positions[key]
-    # We assume that reading from an 8 byte aligned value is atomic.
-    @m[pos..pos+7].unpack('d')[0]
-  end
-
-  def write_value(key, value)
-    @mutex.synchronize do
-      if !@positions.has_key?(key)
-        init_value(key)
-      end
-    end
-    pos = @positions[key]
-    # We assume that writing to an 8 byte aligned value is atomic.
-    @m[pos..pos+7] = [value].pack('d')
-  end
-
-  def close()
-    @m.munmap
-    @f.close
-  end
-
-  private
-
-  # Initialize a value. Lock must be held by caller.
-  def init_value(key)
-    # Pad to be 8-byte aligned.
-    padded = key + (' ' * (8 - (key.length + 4) % 8))
-    value = [key.length, padded, 0.0].pack("lA#{padded.length}d")
-    while @used + value.length > @capacity
-      @capacity *= 2
-      @f.truncate(@capacity)
-      @m = Mmap.new(@f.path, 'rw', Mmap::MAP_SHARED)
-    end
-    @m[@used..@used + value.length] = value
-
-    # Update how much space we've used.
-    @used += value.length
-    @m[0..3] = [@used].pack('l')
-    @positions[key] = @used - 8
-  end
-
-  # Yield (key, value, pos). No locking is performed.
-  def read_all_values
-    pos = 8
-    values = []
-    while pos < @used
-      encoded_len = @m[pos..-1].unpack('l')[0]
-      pos += 4
-      encoded = @m[pos..-1].unpack("A#{encoded_len}")[0]
-      padded_len = encoded_len + (8 - (encoded_len + 4) % 8)
-      pos += padded_len
-      value = @m[pos..-1].unpack('d')[0]
-      values << [encoded, value, pos]
-      pos += 8
-    end
-    values
-  end
-end