purplelight 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b62be6d2a3810b6278d43fadcee4647efb1c758c9bd04ddc69051737e66d1716
+  data.tar.gz: 2950f98c90869bcc3d6619e00adf68113e12197196f43a4c129dab2c1270e47c
+SHA512:
+  metadata.gz: 635a9c3114bc1d6a017a8244dfd6b5cca15f82f19a9e79f59480af91c0e1ec61b72e40703393098f584a2a9d29f68cac9b81f8833c14ccf8d42f527c4cb40c2c
+  data.tar.gz: f24b2faaff4218481b8fa8345842dd1fadeb9174adb92d449008637e072e81861b13bb8f71cacbcb51254fbcca18ea799ca8dfa5ce5c99f418e82262dd5505c1

data/README.md

@@ -0,0 +1,48 @@
+# purplelight
+
+Snapshot MongoDB collections efficiently from Ruby with resumable, partitioned exports to JSONL/CSV/Parquet. Defaults to zstd compression and size-based multi-part outputs. MongoDB 7/8.
+
+### Install
+
+Add to your Gemfile:
+
+```ruby
+gem 'purplelight'
+```
+
+### Quick start
+
+```ruby
+require 'mongo'
+require 'purplelight'
+
+client = Mongo::Client.new(ENV.fetch('MONGO_URL'))
+
+Purplelight.snapshot(
+  client: client,
+  collection: 'users',
+  output: '/data/exports',
+  format: :jsonl,
+  compression: :zstd, # default
+  partitions: 8,
+  batch_size: 2000,
+  query: { active: true },
+  sharding: { mode: :by_size, part_bytes: 256 * 1024 * 1024, prefix: 'users' },
+  resume: { enabled: true },
+  on_progress: ->(s) { puts s.inspect }
+)
+```
+
+Outputs files like:
+
+```
+/data/exports/
+  users-part-000000.jsonl.zst
+  users-part-000001.jsonl.zst
+  users.manifest.json
+```
+
+### Status
+
+Phase 1 (JSONL + zstd, partitioning, resume, size-based sharding) in progress.
+

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/testtask'
+
+task default: [:spec]
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+  task :spec do
+    sh 'echo "RSpec not installed"'
+  end
+end
+
+

data/lib/purplelight/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Purplelight
+  class Error < StandardError; end
+
+  class IncompatibleResumeError < Error; end
+  class OutputExistsError < Error; end
+  class WriterClosedError < Error; end
+end
+
+

data/lib/purplelight/manifest.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require 'securerandom'
+require 'digest'
+require 'fileutils'
+
+module Purplelight
+  class Manifest
+    DEFAULT_VERSION = 1
+
+    attr_reader :path, :data
+
+    def self.query_digest(query, projection)
+      payload = { query: query, projection: projection }
+      Digest::SHA256.hexdigest(JSON.generate(payload))
+    end
+
+    def initialize(path:, data: nil)
+      @path = path
+      @data = data || {
+        'version' => DEFAULT_VERSION,
+        'run_id' => SecureRandom.uuid,
+        'created_at' => Time.now.utc.iso8601,
+        'collection' => nil,
+        'format' => nil,
+        'compression' => nil,
+        'query_digest' => nil,
+        'options' => {},
+        'parts' => [],
+        'partitions' => []
+      }
+      @mutex = Mutex.new
+    end
+
+    def self.load(path)
+      data = JSON.parse(File.read(path))
+      new(path: path, data: data)
+    end
+
+    def save!
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      tmp = path + '.tmp'
+      File.open(tmp, 'w') { |f| f.write(JSON.pretty_generate(@data)) }
+      FileUtils.mv(tmp, path)
+    end
+
+    def configure!(collection:, format:, compression:, query_digest:, options: {})
+      @data['collection'] = collection
+      @data['format'] = format.to_s
+      @data['compression'] = compression.to_s
+      @data['query_digest'] = query_digest
+      @data['options'] = options
+      save!
+    end
+
+    def compatible_with?(collection:, format:, compression:, query_digest:)
+      @data['collection'] == collection &&
+        @data['format'] == format.to_s &&
+        @data['compression'] == compression.to_s &&
+        @data['query_digest'] == query_digest
+    end
+
+    def ensure_partitions!(count)
+      @mutex.synchronize do
+        if @data['partitions'].empty?
+          @data['partitions'] = Array.new(count) { |i| { 'index' => i, 'last_id_exclusive' => nil, 'completed' => false } }
+          save!
+        end
+      end
+    end
+
+    def update_partition_checkpoint!(index, last_id_exclusive)
+      @mutex.synchronize do
+        part = @data['partitions'][index]
+        part['last_id_exclusive'] = last_id_exclusive
+        save!
+      end
+    end
+
+    def mark_partition_complete!(index)
+      @mutex.synchronize do
+        part = @data['partitions'][index]
+        part['completed'] = true
+        save!
+      end
+    end
+
+    def open_part!(path)
+      @mutex.synchronize do
+        idx = @data['parts'].size
+        @data['parts'] << { 'index' => idx, 'path' => path, 'bytes' => 0, 'rows' => 0, 'complete' => false, 'checksum' => nil }
+        save!
+        idx
+      end
+    end
+
+    def add_progress_to_part!(index:, rows_delta:, bytes_delta:)
+      @mutex.synchronize do
+        part = @data['parts'][index]
+        part['rows'] += rows_delta
+        part['bytes'] += bytes_delta
+        save!
+      end
+    end
+
+    def complete_part!(index:, checksum: nil)
+      @mutex.synchronize do
+        part = @data['parts'][index]
+        part['complete'] = true
+        part['checksum'] = checksum
+        save!
+      end
+    end
+
+    def parts
+      @data['parts']
+    end
+
+    def partitions
+      @data['partitions']
+    end
+  end
+end
+
+

data/lib/purplelight/partitioner.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'mongo'
+
+module Purplelight
+  class Partitioner
+    # Builds contiguous _id range filters for N partitions.
+    # For ObjectId _id, we sample quantiles to split into near-equal document counts.
+    def self.object_id_partitions(collection:, query:, partitions:)
+      # Ensure sort order for sampling
+      base_query = collection.find(query || {}, {}.merge(sort: { _id: 1 }))
+
+      # Fast path: if small dataset, just chunk by count
+      total = collection.estimated_document_count
+      return simple_ranges(collection: collection, query: query, partitions: partitions) if total <= partitions * 5_000
+
+      # Sample boundaries: take approx quantiles by skipping
+      step = [total / partitions, 1].max
+      boundaries = []
+      cursor = base_query.projection(_id: 1).batch_size(1_000).no_cursor_timeout
+      i = 0
+      cursor.each do |doc|
+        if (i % step).zero?
+          boundaries << doc['_id']
+        end
+        i += 1
+        break if boundaries.size >= partitions
+      end
+
+      ranges = []
+      prev = nil
+      boundaries.each_with_index do |b, idx|
+        if idx == 0
+          prev = nil
+          next
+        end
+        ranges << build_range(prev, b)
+        prev = b
+      end
+      ranges << build_range(prev, nil)
+
+      ranges.map do |r|
+        filter = query ? query.dup : {}
+        filter['_id'] = r
+        { filter: filter, sort: { _id: 1 }, hint: { _id: 1 } }
+      end
+    end
+
+    def self.simple_ranges(collection:, query:, partitions:)
+      # Split by _id quantiles using min/max endpoints
+      min_id = collection.find(query || {}).projection(_id: 1).sort(_id: 1).limit(1).first&.dig('_id')
+      max_id = collection.find(query || {}).projection(_id: 1).sort(_id: -1).limit(1).first&.dig('_id')
+      return [{ filter: query || {}, sort: { _id: 1 } }] if min_id.nil? || max_id.nil?
+
+      # Create numeric-ish interpolation by sampling
+      ids = collection.find(query || {}).projection(_id: 1).sort(_id: 1).limit(partitions - 1).to_a.map { |d| d['_id'] }
+      boundaries = [min_id] + ids + [max_id]
+      ranges = []
+      boundaries.each_cons(2) do |a, b|
+        ranges << build_range(a, b)
+      end
+
+      ranges.map do |r|
+        filter = query ? query.dup : {}
+        filter['_id'] = r
+        { filter: filter, sort: { _id: 1 }, hint: { _id: 1 } }
+      end
+    end
+
+    def self.build_range(from_id, to_id)
+      if from_id && to_id
+        { '$gt' => from_id, '$lte' => to_id }
+      elsif from_id && !to_id
+        { '$gt' => from_id }
+      elsif !from_id && to_id
+        { '$lte' => to_id }
+      else
+        {}
+      end
+    end
+  end
+end
+
+

data/lib/purplelight/queue.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Purplelight
+  # Sized queue that tracks bytes to apply backpressure.
+  class ByteQueue
+    def initialize(max_bytes: 128 * 1024 * 1024)
+      @max_bytes = max_bytes
+      @queue = []
+      @bytes = 0
+      @closed = false
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+    end
+
+    def push(item, bytes:)
+      @mutex.synchronize do
+        raise "queue closed" if @closed
+        while (@bytes + bytes) > @max_bytes
+          @cv.wait(@mutex)
+        end
+        @queue << [item, bytes]
+        @bytes += bytes
+        @cv.broadcast
+      end
+    end
+
+    def pop
+      @mutex.synchronize do
+        while @queue.empty?
+          if @closed
+            return nil
+          end
+          @cv.wait(@mutex)
+        end
+        item, bytes = @queue.shift
+        @bytes -= bytes
+        @cv.broadcast
+        item
+      end
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+        @cv.broadcast
+      end
+    end
+
+    def size_bytes
+      @mutex.synchronize { @bytes }
+    end
+  end
+end
+
+

data/lib/purplelight/snapshot.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'mongo'
+require 'etc'
+require 'fileutils'
+require_relative 'partitioner'
+require_relative 'queue'
+require_relative 'writer_jsonl'
+require_relative 'manifest'
+require_relative 'errors'
+
+module Purplelight
+  class Snapshot
+    DEFAULTS = {
+      format: :jsonl,
+      compression: :zstd,
+      batch_size: 2_000,
+      partitions: [Etc.respond_to?(:nprocessors) ? [Etc.nprocessors * 2, 4].max : 4, 32].min,
+      queue_size_bytes: 128 * 1024 * 1024,
+      rotate_bytes: 256 * 1024 * 1024,
+      read_concern: :majority,
+      read_preference: :primary,
+      no_cursor_timeout: true
+    }
+
+    def self.snapshot(**options)
+      new(**options).run
+    end
+
+    def initialize(client:, collection:, output:, format: DEFAULTS[:format], compression: DEFAULTS[:compression],
+                   partitions: DEFAULTS[:partitions], batch_size: DEFAULTS[:batch_size],
+                   queue_size_bytes: DEFAULTS[:queue_size_bytes], rotate_bytes: DEFAULTS[:rotate_bytes],
+                   query: {}, projection: nil, hint: nil, mapper: nil,
+                   resume: { enabled: true, state_path: nil, overwrite_incompatible: false },
+                   sharding: { mode: :by_size, part_bytes: DEFAULTS[:rotate_bytes], prefix: nil },
+                   logger: nil, on_progress: nil, read_concern: DEFAULTS[:read_concern], read_preference: DEFAULTS[:read_preference],
+                   no_cursor_timeout: DEFAULTS[:no_cursor_timeout])
+      @client = client
+      @collection = client[collection]
+      @output = output
+      @format = format.to_sym
+      @compression = compression.to_sym
+      @partitions = partitions
+      @batch_size = batch_size
+      @queue_size_bytes = queue_size_bytes
+      @rotate_bytes = rotate_bytes
+      @query = query || {}
+      @projection = projection
+      @hint = hint
+      @mapper = mapper
+      @resume = resume || { enabled: true }
+      @sharding = sharding || { mode: :by_size }
+      @logger = logger
+      @on_progress = on_progress
+      @read_concern = read_concern
+      @read_preference = read_preference
+      @no_cursor_timeout = no_cursor_timeout
+
+      @running = true
+    end
+
+    def run
+      dir, prefix = resolve_output(@output, @format)
+      manifest_path = File.join(dir, "#{prefix}.manifest.json")
+      query_digest = Manifest.query_digest(@query, @projection)
+
+      manifest = if @resume && @resume[:enabled] && File.exist?(manifest_path)
+                   m = Manifest.load(manifest_path)
+                   unless m.compatible_with?(collection: @collection.name, format: @format, compression: @compression, query_digest: query_digest)
+                     if @resume[:overwrite_incompatible]
+                       m = Manifest.new(path: manifest_path)
+                     else
+                       raise IncompatibleResumeError, "existing manifest incompatible with request; pass overwrite_incompatible: true to reset"
+                     end
+                   end
+                   m
+                 else
+                   Manifest.new(path: manifest_path)
+                 end
+
+      manifest.configure!(collection: @collection.name, format: @format, compression: @compression, query_digest: query_digest, options: {
+        partitions: @partitions, batch_size: @batch_size, rotate_bytes: @rotate_bytes
+      })
+      manifest.ensure_partitions!(@partitions)
+
+      # Plan partitions
+      partition_filters = Partitioner.object_id_partitions(collection: @collection, query: @query, partitions: @partitions)
+
+      # Reader queue
+      queue = ByteQueue.new(max_bytes: @queue_size_bytes)
+
+      # Writer
+      case @format
+      when :jsonl
+        writer = WriterJSONL.new(directory: dir, prefix: prefix, compression: @compression, rotate_bytes: @rotate_bytes, logger: @logger, manifest: manifest)
+      else
+        raise ArgumentError, "format not implemented: #{@format}"
+      end
+
+      # Start reader threads
+      readers = partition_filters.each_with_index.map do |pf, idx|
+        Thread.new do
+          read_partition(idx: idx, filter_spec: pf, queue: queue, batch_size: @batch_size, manifest: manifest)
+        end
+      end
+
+      # Writer loop
+      writer_thread = Thread.new do
+        loop do
+          batch = queue.pop
+          break if batch.nil?
+          writer.write_many(batch)
+        end
+      ensure
+        writer.close
+      end
+
+      progress_thread = Thread.new do
+        last = Time.now
+        loop do
+          sleep 2
+          break unless @running
+          @on_progress&.call({ queue_bytes: queue.size_bytes })
+        end
+      end
+
+      # Join readers
+      readers.each(&:join)
+      queue.close
+      writer_thread.join
+      @running = false
+      progress_thread.join
+      true
+    end
+
+    private
+
+    def resolve_output(output, format)
+      if File.directory?(output) || output.end_with?("/")
+        dir = output
+        prefix = @sharding[:prefix] || @collection.name
+      else
+        dir = File.dirname(output)
+        basename = File.basename(output)
+        prefix = basename.sub(/\.(jsonl|csv|parquet)(\.(zst|gz))?\z/, '')
+      end
+      FileUtils.mkdir_p(dir)
+      [dir, prefix]
+    end
+
+    def read_partition(idx:, filter_spec:, queue:, batch_size:, manifest:)
+      filter = filter_spec[:filter]
+      sort = filter_spec[:sort] || { _id: 1 }
+      hint = filter_spec[:hint] || { _id: 1 }
+
+      # Resume from checkpoint if present
+      checkpoint = manifest.partitions[idx] && manifest.partitions[idx]['last_id_exclusive']
+      if checkpoint
+        filter = filter.dup
+        filter['_id'] = (filter['_id'] || {}).merge({ '$gt' => checkpoint })
+      end
+
+      opts = { sort: sort, hint: hint }
+      opts[:projection] = @projection if @projection
+      opts[:batch_size] = batch_size if batch_size
+      opts[:no_cursor_timeout] = @no_cursor_timeout
+      opts[:read] = { mode: @read_preference }
+      opts[:read_concern] = @read_concern
+
+      cursor = @collection.find(filter, opts)
+
+      buffer = []
+      buffer_bytes = 0
+      last_id = checkpoint
+      begin
+        cursor.each do |doc|
+          last_id = doc['_id']
+          doc = @mapper.call(doc) if @mapper
+          json = Oj.dump(doc, mode: :compat)
+          bytes = json.bytesize + 1 # newline later
+          buffer << doc
+          buffer_bytes += bytes
+          if buffer.length >= batch_size || buffer_bytes >= 1_000_000
+            queue.push(buffer, bytes: buffer_bytes)
+            manifest.update_partition_checkpoint!(idx, last_id)
+            buffer = []
+            buffer_bytes = 0
+          end
+        end
+        unless buffer.empty?
+          queue.push(buffer, bytes: buffer_bytes)
+          manifest.update_partition_checkpoint!(idx, last_id)
+          buffer = []
+          buffer_bytes = 0
+        end
+        manifest.mark_partition_complete!(idx)
+      rescue => e
+        # Re-raise to fail the thread; could implement retry/backoff
+        raise e
+      end
+    end
+  end
+end
+
+

data/lib/purplelight/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Purplelight
+  VERSION = "0.1.0"
+end
+
+

data/lib/purplelight/writer_jsonl.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'oj'
+require 'zlib'
+require 'fileutils'
+
+begin
+  require 'zstds'
+rescue LoadError
+  # zstd not available; will fallback to gzip
+end
+
+module Purplelight
+  class WriterJSONL
+    DEFAULT_ROTATE_BYTES = 256 * 1024 * 1024
+
+    def initialize(directory:, prefix:, compression: :zstd, rotate_bytes: DEFAULT_ROTATE_BYTES, logger: nil, manifest: nil)
+      @directory = directory
+      @prefix = prefix
+      @compression = compression
+      @rotate_bytes = rotate_bytes
+      @logger = logger
+      @manifest = manifest
+
+      @part_index = nil
+      @io = nil
+      @bytes_written = 0
+      @rows_written = 0
+      @file_seq = 0
+      @closed = false
+    end
+
+    def write_many(array_of_docs)
+      ensure_open!
+      buffer = array_of_docs.map { |doc| Oj.dump(doc, mode: :compat) + "\n" }.join
+      write_buffer(buffer)
+      @rows_written += array_of_docs.size
+      @manifest&.add_progress_to_part!(index: @part_index, rows_delta: array_of_docs.size, bytes_delta: buffer.bytesize)
+    end
+
+    def rotate_if_needed
+      return if @rotate_bytes.nil?
+      return if @bytes_written < @rotate_bytes
+      rotate!
+    end
+
+    def close
+      return if @closed
+      if @io
+        finalize_current_part!
+        @io.close
+      end
+      @closed = true
+    end
+
+    private
+
+    def ensure_open!
+      return if @io
+      FileUtils.mkdir_p(@directory)
+      path = next_part_path
+      @part_index = @manifest&.open_part!(path) if @manifest
+      raw = File.open(path, 'wb')
+      @io = build_compressed_io(raw)
+      @bytes_written = 0
+      @rows_written = 0
+    end
+
+    def build_compressed_io(raw)
+      case @compression.to_s
+      when 'zstd'
+        if defined?(ZSTDS)
+          # ZSTDS::Writer supports IO-like interface
+          return ZSTDS::Writer.open(raw, level: 10)
+        else
+          @logger&.warn("zstd not available, falling back to gzip")
+          return Zlib::GzipWriter.new(raw)
+        end
+      when 'gzip'
+        return Zlib::GzipWriter.new(raw)
+      when 'none'
+        return raw
+      else
+        raise ArgumentError, "unknown compression: #{@compression}"
+      end
+    end
+
+    def write_buffer(buffer)
+      @io.write(buffer)
+      @bytes_written += buffer.bytesize
+      rotate_if_needed
+    end
+
+    def rotate!
+      return unless @io
+      finalize_current_part!
+      @io.close
+      @io = nil
+      ensure_open!
+    end
+
+    def finalize_current_part!
+      @io.flush if @io.respond_to?(:flush)
+      # Could compute checksum here by re-reading, or maintain on the fly; omit for v1
+      @manifest&.complete_part!(index: @part_index, checksum: nil)
+      @file_seq += 1
+    end
+
+    def next_part_path
+      ext = 'jsonl'
+      filename = format("%s-part-%06d.%s", @prefix, @file_seq, ext)
+      filename += ".zst" if @compression.to_s == 'zstd'
+      filename += ".gz" if @compression.to_s == 'gzip'
+      File.join(@directory, filename)
+    end
+  end
+end
+
+

data/lib/purplelight.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "purplelight/version"
+require_relative "purplelight/errors"
+require_relative "purplelight/manifest"
+require_relative "purplelight/snapshot"
+
+module Purplelight
+  # Convenience top-level API.
+  # See Purplelight::Snapshot for options.
+  def self.snapshot(**options)
+    Snapshot.snapshot(**options)
+  end
+end
+
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: purplelight
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Purplelight Authors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.19'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: High-throughput, resumable snapshots of MongoDB collections with partitioning,
+  multi-threaded readers, and size-based sharded outputs.
+email:
+- devnull@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/purplelight.rb
+- lib/purplelight/errors.rb
+- lib/purplelight/manifest.rb
+- lib/purplelight/partitioner.rb
+- lib/purplelight/queue.rb
+- lib/purplelight/snapshot.rb
+- lib/purplelight/version.rb
+- lib/purplelight/writer_jsonl.rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/example/purplelight
+  source_code_uri: https://github.com/example/purplelight
+  changelog_uri: https://github.com/example/purplelight/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Snapshot MongoDB collections efficiently to JSONL/CSV/Parquet
+test_files: []