elasticgraph-warehouse_lambda 1.0.3.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e5870b53e8b751aea6f3fd4b932482da4a2eaac9a1a81cf971ab478958fc2a5
+  data.tar.gz: 8270c7bb72f34432d5372661463732b73d3dbf146f48c807223d015ed5bebbad
+SHA512:
+  metadata.gz: 7cda9ec664426b19468fa308e33f100d656c802131f68208f93e9ad70eb3da3e60ba7295b59163c153aaa8eb07874272f702a928d96822ad92357827d84e5640
+  data.tar.gz: c5d0306aa7f53fbf092e35ba42f9fd6501cb6cb4cee7ec919d846649289a0d72c11a2e07d36774d485a52690ffb6b19441575d930a11ecdd503519219ab8e0b0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 - 2026 Block, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# ElasticGraph::WarehouseLambda
+
+Write ElasticGraph-shaped JSONL files to S3, packaged for AWS Lambda.
+
+This gem adapts ElasticGraph's indexing pipeline so that, instead of writing to the datastore,
+it writes batched, gzipped [JSON Lines](https://jsonlines.org/) (JSONL) files to Amazon S3. Each line in the file
+conforms to a specific JSON Schema version for the corresponding object type, with files partitioned by schema version.
+
+**Note:** This code does not deduplicate when writing to S3, so the data will contain all events
+and versions published, plus any Lambda retries. Consumers of the S3 bucket are responsible for
+deduplicating records by version when loading data into a warehouse.
+
+## Dependency Diagram
+
+```mermaid
+graph LR;
+    classDef targetGemStyle fill:#FADBD8,stroke:#EC7063,color:#000,stroke-width:2px;
+    classDef otherEgGemStyle fill:#A9DFBF,stroke:#2ECC71,color:#000;
+    classDef externalGemStyle fill:#E0EFFF,stroke:#70A1D7,color:#2980B9;
+    elasticgraph-warehouse_lambda["elasticgraph-warehouse_lambda"];
+    class elasticgraph-warehouse_lambda targetGemStyle;
+    elasticgraph-indexer_lambda["elasticgraph-indexer_lambda"];
+    elasticgraph-warehouse_lambda --> elasticgraph-indexer_lambda;
+    class elasticgraph-indexer_lambda otherEgGemStyle;
+    elasticgraph-lambda_support["elasticgraph-lambda_support"];
+    elasticgraph-warehouse_lambda --> elasticgraph-lambda_support;
+    class elasticgraph-lambda_support otherEgGemStyle;
+    aws-sdk-s3["aws-sdk-s3"];
+    elasticgraph-warehouse_lambda --> aws-sdk-s3;
+    class aws-sdk-s3 externalGemStyle;
+    ox["ox"];
+    elasticgraph-warehouse_lambda --> ox;
+    class ox externalGemStyle;
+    click aws-sdk-s3 href "https://rubygems.org/gems/aws-sdk-s3" "Open on RubyGems.org" _blank;
+    click ox href "https://rubygems.org/gems/ox" "Open on RubyGems.org" _blank;
+```
+
+## What it does
+
+- Consumes ElasticGraph indexing operations and groups them by GraphQL type and JSON schema version
+- Transforms each operation into a flattened JSON document that matches your ElasticGraph schema
+- Writes one gzipped JSONL file per type per JSON schema version per batch to S3 with deterministic keys:
+  - `s3://<bucket>/<s3_path_prefix>/<TypeName>/v<json_schema_version>/<YYYY-MM-DD>/<uuid>.jsonl.gz`
+- Emits structured logs for observability (counts, sizes, S3 key, etc.)
+
+## When to use it
+
+Use this when you need a durable, append-only export of ElasticGraph data suitable for ingestion
+by downstream systems (e.g., data warehouses, lakehouses, or offline analytics pipelines). It's a
+drop-in replacement for the Indexer's datastore router: instead of indexing into the datastore,
+you persist JSONL to S3.
+
+This is particularly useful when you want to pair a full-fledged SQL-based data warehouse
+(such as Databricks) with ElasticGraph. Managing the warehouse via ElasticGraph ensures
+that the schema and data in the warehouse exactly matches what's exposed from your
+ElasticGraph GraphQL API, so that clients can seamlessly switch between GraphQL and SQL.
+
+## Configuration
+
+Configuration is sourced from your normal ElasticGraph YAML settings (via ELASTICGRAPH_YAML_CONFIG).
+
+```yaml
+warehouse:
+  s3_path_prefix: dumped-data/Data001 # Required: full S3 key prefix for organizing exports
+  s3_bucket_name: my-bucket-name      # Required: the S3 bucket to write JSONL files into
+  aws_region: us-west-2               # Optional: AWS region for S3 bucket (defaults to AWS SDK region resolution)
+```
+
+## Key format
+
+Files are written with the following S3 key format:
+
+```
+<s3_path_prefix>/<TypeName>/v<json_schema_version>/<YYYY-MM-DD>/<uuid>.jsonl.gz
+```
+
+- **s3_path_prefix**: Configurable in YAML (warehouse.s3_path_prefix). This is the full prefix you control,
+  so you can organize your data however you like (e.g., "dumped-data/Data001" or "prod/analytics/v2").
+- **TypeName**: GraphQL type from the ElasticGraph event
+- **json_schema_version**: The JSON Schema version **selected based on the ingested event's requested version**
+  (or the closest available version if the exact version isn't available). This ensures data partitioning
+  matches the actual schema version used to process each event, making it easier to handle schema evolution
+  and version-specific data processing.
+- **YYYY-MM-DD**: UTC date when the batch was processed (aligns with common data warehouse
+  partitioning strategies)
+- **uuid**: A random UUID for uniqueness
+
+## Runtime and deps
+
+- Runs in AWS Lambda via elasticgraph-lambda_support
+- Depends on elasticgraph-indexer_lambda for event preparation and schema artifacts
+- Uses aws-sdk-s3 to write to S3
+
+## Observability
+
+The Lambda logs structured events:
+- WarehouseLambdaReceivedBatch: counts per type for incoming batch
+- DumpedToWarehouseFile: S3 key, type, record_count, json_size, gzip_size
+
+## License
+
+MIT © Block, Inc.

data/lib/elastic_graph/warehouse_lambda/config.rb

@@ -0,0 +1,47 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/support/config"
+
+module ElasticGraph
+  # AWS Lambda integration for exporting ElasticGraph indexing data to S3 as gzipped JSONL files.
+  # This allows downstream analytics pipelines, data warehouses, and lakehouses to consume
+  # ElasticGraph data without querying the primary datastore.
+  class WarehouseLambda
+    # Configuration for the warehouse lambda.
+    #
+    # Defines S3 settings for exporting ElasticGraph data as gzipped JSONL files.
+    class Config < Support::Config.define(:s3_path_prefix, :s3_bucket_name, :aws_region)
+      json_schema at: "warehouse",
+        optional: true,
+        description: "Configuration for the warehouse lambda used by `elasticgraph-warehouse_lambda`.",
+        properties: {
+          s3_path_prefix: {
+            description: "The S3 path prefix to use when storing data files.",
+            type: "string",
+            pattern: /^\S+$/.source, # No whitespace allowed
+            examples: ["Data001", "my-prefix"]
+          },
+          s3_bucket_name: {
+            description: "The S3 bucket name to write JSONL files into.",
+            type: "string",
+            pattern: /^\S+$/.source, # No whitespace allowed
+            examples: ["my-warehouse-bucket", "data-lake-prod"]
+          },
+          aws_region: {
+            description: "Optional AWS region for the S3 bucket. If not specified, uses AWS SDK default region resolution (AWS_REGION env var, instance metadata, etc.).",
+            type: ["string", "null"],
+            pattern: /^\S+$/.source, # No whitespace allowed
+            examples: ["us-west-2", "eu-central-1"],
+            default: nil
+          }
+        },
+        required: ["s3_path_prefix", "s3_bucket_name"]
+    end
+  end
+end

data/lib/elastic_graph/warehouse_lambda/lambda_function.rb

@@ -0,0 +1,43 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/lambda_support/lambda_function"
+require "json"
+
+module ElasticGraph
+  class WarehouseLambda
+    # @private
+    class LambdaFunction
+      prepend LambdaSupport::LambdaFunction
+
+      # @dynamic sqs_processor
+      attr_reader :sqs_processor
+
+      def initialize
+        require "elastic_graph/warehouse_lambda"
+        require "elastic_graph/indexer_lambda/sqs_processor"
+
+        warehouse_lambda = WarehouseLambda.warehouse_lambda_from_env
+        ignore_sqs_latency_timestamps_from_arns = ::JSON.parse(ENV.fetch("IGNORE_SQS_LATENCY_TIMESTAMPS_FROM_ARNS", "[]")).to_set
+
+        @sqs_processor = IndexerLambda::SqsProcessor.new(
+          warehouse_lambda.processor,
+          ignore_sqs_latency_timestamps_from_arns: ignore_sqs_latency_timestamps_from_arns,
+          logger: warehouse_lambda.logger
+        )
+      end
+
+      def handle_request(event:, context:)
+        sqs_processor.process(event)
+      end
+    end
+  end
+end
+
+# Lambda handler for `elasticgraph-warehouse_lambda`.
+DumpWarehouseData = ElasticGraph::WarehouseLambda::LambdaFunction.new

data/lib/elastic_graph/warehouse_lambda/warehouse_dumper.rb

@@ -0,0 +1,143 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/constants"
+require "elastic_graph/indexer/datastore_indexing_router"
+require "elastic_graph/indexer/operation/result"
+require "json"
+require "securerandom"
+require "time"
+require "zlib"
+
+module ElasticGraph
+  class WarehouseLambda
+    # Responsible for dumping data into a data warehouse. Implements the same interface as `DatastoreIndexingRouter` from
+    # `elasticgraph-indexer` so that it can be used in place of the standard datastore indexing router.
+    class WarehouseDumper
+      # @return [String] message type for logging when a batch is received
+      LOG_MSG_RECEIVED_BATCH = "WarehouseLambdaReceivedBatch"
+
+      # @return [String] message type for logging when a file is dumped to S3
+      LOG_MSG_DUMPED_FILE = "DumpedToWarehouseFile"
+
+      def initialize(logger:, s3_client:, s3_bucket_name:, s3_file_prefix:, clock:)
+        @logger = logger
+        @s3_client = s3_client
+        @s3_bucket_name = s3_bucket_name
+        @s3_file_prefix = s3_file_prefix
+        @clock = clock
+      end
+
+      # Processes a batch of indexing operations by dumping them to S3 as gzipped JSONL files.
+      # Operations are grouped by GraphQL type and JSON schema version, with each group written to a separate file.
+      #
+      # @param operations [Array<Operation>] the indexing operations to process
+      # @param refresh [Boolean] ignored (included for interface compatibility with DatastoreIndexingRouter)
+      # @return [BulkResult] result containing success status for all operations
+      def bulk(operations, refresh: false)
+        operations_by_type_and_json_schema_version = operations.group_by { |op| [op.event.fetch("type"), op.event.fetch(JSON_SCHEMA_VERSION_KEY)] }
+
+        @logger.info({
+          "message_type" => LOG_MSG_RECEIVED_BATCH,
+          "record_counts_by_type" => operations_by_type_and_json_schema_version.transform_keys { |(type, _json_schema_version)| type }.transform_values(&:size)
+        })
+
+        operations_by_type_and_json_schema_version.each do |(type, json_schema_version), operations|
+          # Operations coming from the indexer are always Update operations for warehouse dumping
+          update_operations = operations # : ::Array[::ElasticGraph::Indexer::Operation::Update]
+          jsonl_data = build_jsonl_file_from(update_operations)
+
+          # Skip S3 upload if all operations were filtered out (no data to write)
+          next if jsonl_data.empty?
+
+          gzip_data = compress(jsonl_data)
+          s3_key = generate_s3_key_for(type, json_schema_version)
+
+          # Use if_none_match: "*" to prevent overwrites (defense-in-depth, though UUIDs make collisions impossible)
+          @s3_client.put_object(
+            bucket: @s3_bucket_name,
+            key: s3_key,
+            body: gzip_data,
+            checksum_algorithm: :sha256,
+            if_none_match: "*"
+          )
+
+          @logger.info({
+            "message_type" => LOG_MSG_DUMPED_FILE,
+            "s3_bucket" => @s3_bucket_name,
+            "s3_key" => s3_key,
+            "type" => type,
+            JSON_SCHEMA_VERSION_KEY => json_schema_version,
+            "record_count" => operations.size,
+            "json_size" => jsonl_data.bytesize,
+            "gzip_size" => gzip_data.bytesize
+          })
+        end
+
+        ops_and_results = operations.map do |op|
+          [op, ::ElasticGraph::Indexer::Operation::Result.success_of(op)]
+        end # : ::Array[[::ElasticGraph::Indexer::_Operation, ::ElasticGraph::Indexer::Operation::Result]]
+
+        ::ElasticGraph::Indexer::DatastoreIndexingRouter::BulkResult.new({"warehouse" => ops_and_results})
+      end
+
+      # Returns existing event versions for the given operations.
+      # Always returns an empty hash since the warehouse doesn't maintain version state.
+      #
+      # @param operations [Array<Operation>] the operations to check (unused)
+      # @return [Hash] empty hash (warehouse doesn't track versions)
+      def source_event_versions_in_index(operations)
+        {}
+      end
+
+      private
+
+      def generate_s3_key_for(type, json_schema_version)
+        date = @clock.now.utc.strftime("%Y-%m-%d")
+        uuid = ::SecureRandom.uuid
+
+        [
+          @s3_file_prefix,
+          type,
+          "v#{json_schema_version}",
+          date,
+          "#{uuid}.jsonl.gz"
+        ].join("/")
+      end
+
+      def build_jsonl_file_from(operations)
+        operation_payloads = operations.filter_map do |op|
+          # Only include operations where the update target matches the event type (excludes derived indices)
+          next nil if op.update_target.type != op.event.fetch("type")
+
+          params = op.to_datastore_bulk[1].fetch(:script).fetch(:params)
+          data = params.fetch("data").merge({
+            "id" => params.fetch("id"),
+            "__eg_version" => params.fetch("version")
+          })
+
+          ::JSON.generate(data)
+        end
+
+        operation_payloads.join("\n")
+      end
+
+      def compress(jsonl_data)
+        io = ::StringIO.new
+        gz = ::Zlib::GzipWriter.new(io, ::Zlib::DEFAULT_COMPRESSION, ::Zlib::DEFAULT_STRATEGY)
+
+        begin
+          gz << jsonl_data
+        ensure
+          gz.close
+        end
+        io.string
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse_lambda.rb

@@ -0,0 +1,120 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/datastore_core"
+require "elastic_graph/indexer/config"
+require "elastic_graph/lambda_support"
+require "elastic_graph/support/from_yaml_file"
+require "elastic_graph/warehouse_lambda/config"
+
+module ElasticGraph
+  # Wraps an {Indexer} to dump data to S3 instead of indexing to a datastore.
+  # This is a stateful wrapper class (unlike {IndexerLambda} and {GraphQLLambda},
+  # which are namespace modules), as it manages the relationship between the
+  # indexer, S3 client, and warehouse dumper.
+  #
+  # @private
+  class WarehouseLambda
+    extend Support::FromYamlFile
+
+    # Builds an `ElasticGraph::WarehouseLambda` instance from our lambda ENV vars.
+    def self.warehouse_lambda_from_env
+      LambdaSupport.build_from_env(WarehouseLambda)
+    end
+
+    # @return [Config] warehouse configuration
+    # @return [Indexer::Config] indexer configuration
+    # @return [DatastoreCore] datastore core for accessing schema artifacts
+    # @return [Logger] logger instance from datastore core
+    # @return [Module] clock module for time generation
+    # @dynamic config, indexer_config, datastore_core, logger, clock, indexer
+    attr_reader :config, :indexer_config, :datastore_core, :logger, :clock
+
+    # Builds an `ElasticGraph::WarehouseLambda` instance from parsed YAML configuration.
+    #
+    # @param parsed_yaml [Hash] parsed YAML configuration
+    # @yield [Datastore::Client] optional block to customize the datastore client
+    # @return [WarehouseLambda] configured warehouse lambda instance
+    def self.from_parsed_yaml(parsed_yaml, &datastore_client_customization_block)
+      new(
+        config: Config.from_parsed_yaml!(parsed_yaml),
+        indexer_config: Indexer::Config.from_parsed_yaml(parsed_yaml) || Indexer::Config.new,
+        datastore_core: DatastoreCore.from_parsed_yaml(parsed_yaml, &datastore_client_customization_block)
+      )
+    end
+
+    # Initializes a WarehouseLambda instance.
+    #
+    # @param config [Config] warehouse configuration
+    # @param indexer_config [Config] indexer configuration
+    # @param datastore_core [DatastoreCore] datastore core for accessing schema artifacts
+    # @param clock [Module] clock module for time generation (defaults to {::Time})
+    # @param s3_client [Aws::S3::Client, nil] optional S3 client (for testing)
+    def initialize(config:, indexer_config:, datastore_core:, clock: ::Time, s3_client: nil)
+      @config = config
+      @indexer_config = indexer_config
+      @datastore_core = datastore_core
+      @logger = datastore_core.logger
+      @clock = clock
+      @s3_client = s3_client
+    end
+
+    # Returns the processor from the indexer for event processing.
+    #
+    # @return [Processor] the processor that handles incoming events
+    def processor
+      indexer.processor
+    end
+
+    # Returns the indexer instance, lazily building it on first access.
+    #
+    # @return [Indexer] the indexer that processes events
+    def indexer
+      @indexer ||= begin
+        require "elastic_graph/indexer"
+        Indexer.new(
+          config: indexer_config,
+          datastore_core: datastore_core,
+          datastore_router: warehouse_dumper,
+          clock: clock
+        )
+      end
+    end
+
+    # Returns the warehouse dumper instance, lazily building it on first access.
+    #
+    # @return [WarehouseDumper] the dumper that writes data to S3
+    def warehouse_dumper
+      @warehouse_dumper ||= begin
+        require "elastic_graph/warehouse_lambda/warehouse_dumper"
+        WarehouseDumper.new(
+          logger: logger,
+          s3_client: s3_client,
+          s3_bucket_name: config.s3_bucket_name,
+          s3_file_prefix: config.s3_path_prefix,
+          clock: clock
+        )
+      end
+    end
+
+    # Returns the S3 client instance, lazily building it on first access.
+    #
+    # @return [Aws::S3::Client] the S3 client for uploading data
+    def s3_client
+      @s3_client ||= begin
+        require "aws-sdk-s3"
+
+        if (region = config.aws_region)
+          ::Aws::S3::Client.new(region: region)
+        else
+          ::Aws::S3::Client.new
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: elasticgraph-warehouse_lambda
+version: !ruby/object:Gem::Version
+  version: 1.0.3.rc1
+platform: ruby
+authors:
+- Myron Marston
+- Josh Wilson
+- Block Engineering
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-indexer_lambda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-lambda_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.212'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.212'
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.23
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.14.23
+- !ruby/object:Gem::Dependency
+  name: aws_lambda_ric
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-opensearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+email:
+- joshuaw@squareup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/elastic_graph/warehouse_lambda.rb
+- lib/elastic_graph/warehouse_lambda/config.rb
+- lib/elastic_graph/warehouse_lambda/lambda_function.rb
+- lib/elastic_graph/warehouse_lambda/warehouse_dumper.rb
+homepage: https://block.github.io/elasticgraph/
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/block/elasticgraph/issues
+  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v1.0.3.rc1
+  documentation_uri: https://block.github.io/elasticgraph/api-docs/v1.0.3.rc1/
+  homepage_uri: https://block.github.io/elasticgraph/
+  source_code_uri: https://github.com/block/elasticgraph/tree/v1.0.3.rc1/elasticgraph-warehouse_lambda
+  gem_category: lambda
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: ElasticGraph lambda for ingesting data into a warehouse.
+test_files: []