klime 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 330590153e5a8620ea195eeac0af41c0eacbc5d4619f3cf22c05192fcaa071ee
+  data.tar.gz: 54cf4a7e4afb4680dcd7386c056058184ac5fb0f46132f980074a115c1f6ac47
+SHA512:
+  metadata.gz: b89311ba42ebcc5cf409fbd331e2f77dfcf72455dc2c832a34c9392aaabe216949adedb90f2999cb4a88ae3ede702452db82074694db79a87b33dbe4c5c01a9d
+  data.tar.gz: 448ef16a67fc2ce3cf81766bce565cffc60a2ca5cb91dab198cd8a81ca825b643ec5b9c044605e436f56cdbb98ff88a4f9763b507bda1f929b3b05ca101a198a

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Klime
+
+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,265 @@
+# klime
+
+Klime SDK for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'klime'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install klime
+```
+
+## Quick Start
+
+```ruby
+require 'klime'
+
+client = Klime::Client.new(
+  write_key: 'your-write-key'
+)
+
+# Identify a user
+client.identify('user_123', {
+  email: 'user@example.com',
+  name: 'Stefan'
+})
+
+# Track an event
+client.track('Button Clicked', {
+  button_name: 'Sign up',
+  plan: 'pro'
+}, user_id: 'user_123')
+
+# Associate user with a group and set group traits
+client.group('org_456', {
+  name: 'Acme Inc',
+  plan: 'enterprise'
+}, user_id: 'user_123')
+
+# Or just link the user to a group (if traits are already set)
+client.group('org_456', user_id: 'user_123')
+
+# Shutdown gracefully
+client.shutdown
+```
+
+## API Reference
+
+### Constructor
+
+```ruby
+Klime::Client.new(
+  write_key:,              # Required: Your Klime write key
+  endpoint: nil,           # Optional: API endpoint (default: https://i.klime.com)
+  flush_interval: nil,     # Optional: Milliseconds between flushes (default: 2000)
+  max_batch_size: nil,     # Optional: Max events per batch (default: 20, max: 100)
+  max_queue_size: nil,     # Optional: Max queued events (default: 1000)
+  retry_max_attempts: nil, # Optional: Max retry attempts (default: 5)
+  retry_initial_delay: nil, # Optional: Initial retry delay in ms (default: 1000)
+  flush_on_shutdown: nil   # Optional: Auto-flush on exit (default: true)
+)
+```
+
+### Methods
+
+#### `track(event_name, properties = nil, user_id: nil, group_id: nil, ip: nil)`
+
+Track a user event. A `user_id` is required for events to be useful in Klime.
+
+```ruby
+client.track('Button Clicked', {
+  button_name: 'Sign up',
+  plan: 'pro'
+}, user_id: 'user_123')
+
+# With IP address (for geolocation)
+client.track('Button Clicked', {
+  button_name: 'Sign up',
+  plan: 'pro'
+}, user_id: 'user_123', ip: '192.168.1.1')
+```
+
+> **Advanced**: The `group_id` parameter is available for multi-tenant scenarios where a user belongs to multiple organizations and you need to specify which organization context the event occurred in.
+
+#### `identify(user_id, traits = nil, ip: nil)`
+
+Identify a user with traits.
+
+```ruby
+client.identify('user_123', {
+  email: 'user@example.com',
+  name: 'Stefan'
+}, ip: '192.168.1.1')
+```
+
+#### `group(group_id, traits = nil, user_id: nil, ip: nil)`
+
+Associate a user with a group and/or set group traits.
+
+```ruby
+# Associate user with a group and set group traits (most common)
+client.group('org_456', {
+  name: 'Acme Inc',
+  plan: 'enterprise'
+}, user_id: 'user_123')
+
+# Just link a user to a group (traits already set or not needed)
+client.group('org_456', user_id: 'user_123')
+
+# Just update group traits (e.g., from a webhook or background job)
+client.group('org_456', {
+  plan: 'enterprise',
+  employee_count: 50
+})
+```
+
+#### `flush`
+
+Manually flush queued events immediately.
+
+```ruby
+client.flush
+```
+
+#### `shutdown`
+
+Gracefully shutdown the client, flushing remaining events.
+
+```ruby
+client.shutdown
+```
+
+## Features
+
+- **Automatic Batching**: Events are automatically batched and sent every 2 seconds or when the batch size reaches 20 events
+- **Automatic Retries**: Failed requests are automatically retried with exponential backoff
+- **Thread-Safe**: Safe to use from multiple threads
+- **Process Exit Handling**: Automatically flushes events on process exit (via `at_exit`)
+- **Zero Dependencies**: Uses only Ruby standard library
+
+## Configuration
+
+### Default Values
+
+- `flush_interval`: 2000ms
+- `max_batch_size`: 20 events
+- `max_queue_size`: 1000 events
+- `retry_max_attempts`: 5 attempts
+- `retry_initial_delay`: 1000ms
+- `flush_on_shutdown`: true
+
+## Error Handling
+
+The SDK automatically handles:
+
+- **Transient errors** (429, 503, network failures): Retries with exponential backoff
+- **Permanent errors** (400, 401): Logs error and drops event
+- **Rate limiting**: Respects `Retry-After` header
+
+## Size Limits
+
+- Maximum event size: 200KB
+- Maximum batch size: 10MB
+- Maximum events per batch: 100
+
+Events exceeding these limits are rejected and logged.
+
+## Rails Example
+
+```ruby
+# config/initializers/klime.rb
+require 'klime'
+
+KLIME = Klime::Client.new(
+  write_key: ENV['KLIME_WRITE_KEY']
+)
+
+# Ensure graceful shutdown
+at_exit { KLIME.shutdown }
+```
+
+```ruby
+# app/controllers/buttons_controller.rb
+class ButtonsController < ApplicationController
+  def click
+    KLIME.track('Button Clicked', {
+      button_name: params[:button_name]
+    }, user_id: current_user&.id&.to_s, ip: request.remote_ip)
+
+    render json: { success: true }
+  end
+end
+```
+
+## Sinatra Example
+
+```ruby
+require 'sinatra'
+require 'klime'
+
+client = Klime::Client.new(write_key: ENV['KLIME_WRITE_KEY'])
+
+post '/api/button-clicked' do
+  data = JSON.parse(request.body.read)
+
+  client.track('Button Clicked', {
+    button_name: data['buttonName']
+  }, user_id: data['userId'], ip: request.ip)
+
+  { success: true }.to_json
+end
+
+# Graceful shutdown
+at_exit { client.shutdown }
+```
+
+## Rack Middleware Example
+
+```ruby
+# lib/klime_middleware.rb
+require 'klime'
+
+class KlimeMiddleware
+  def initialize(app, write_key:)
+    @app = app
+    @client = Klime::Client.new(write_key: write_key)
+  end
+
+  def call(env)
+    status, headers, response = @app.call(env)
+
+    # Track page views for authenticated users
+    user_id = env['rack.session']&.dig('user_id')
+    if user_id && env['REQUEST_METHOD'] == 'GET' && status == 200
+      @client.track('Page View', {
+        path: env['PATH_INFO'],
+        method: env['REQUEST_METHOD']
+      }, user_id: user_id, ip: env['REMOTE_ADDR'])
+    end
+
+    [status, headers, response]
+  end
+end
+```
+
+## Requirements
+
+- Ruby 2.6 or higher
+- No external dependencies (uses only standard library)
+
+## License
+
+MIT

data/lib/klime/client.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "thread"
+
+module Klime
+  # Main client for the Klime analytics SDK
+  #
+  # @example Basic usage
+  #   client = Klime::Client.new(write_key: 'your-write-key')
+  #   client.track('Button Clicked', { button_name: 'Sign up' })
+  #   client.shutdown
+  class Client
+    DEFAULT_ENDPOINT = "https://i.klime.com"
+    DEFAULT_FLUSH_INTERVAL = 2000 # milliseconds
+    DEFAULT_MAX_BATCH_SIZE = 20
+    DEFAULT_MAX_QUEUE_SIZE = 1000
+    DEFAULT_RETRY_MAX_ATTEMPTS = 5
+    DEFAULT_RETRY_INITIAL_DELAY = 1000 # milliseconds
+    MAX_BATCH_SIZE = 100
+    MAX_EVENT_SIZE_BYTES = 200 * 1024 # 200KB
+    MAX_BATCH_SIZE_BYTES = 10 * 1024 * 1024 # 10MB
+
+    # Create a new Klime client
+    #
+    # @param write_key [String] Your Klime write key (required)
+    # @param endpoint [String] API endpoint URL (default: https://i.klime.com)
+    # @param flush_interval [Integer] Milliseconds between automatic flushes (default: 2000)
+    # @param max_batch_size [Integer] Maximum events per batch (default: 20, max: 100)
+    # @param max_queue_size [Integer] Maximum queued events (default: 1000)
+    # @param retry_max_attempts [Integer] Maximum retry attempts (default: 5)
+    # @param retry_initial_delay [Integer] Initial retry delay in milliseconds (default: 1000)
+    # @param flush_on_shutdown [Boolean] Auto-flush on exit (default: true)
+    def initialize(
+      write_key:,
+      endpoint: nil,
+      flush_interval: nil,
+      max_batch_size: nil,
+      max_queue_size: nil,
+      retry_max_attempts: nil,
+      retry_initial_delay: nil,
+      flush_on_shutdown: nil
+    )
+      raise ConfigurationError, "write_key is required" if write_key.nil? || write_key.empty?
+
+      @write_key = write_key
+      @endpoint = endpoint || DEFAULT_ENDPOINT
+      @flush_interval = flush_interval || DEFAULT_FLUSH_INTERVAL
+      @max_batch_size = [max_batch_size || DEFAULT_MAX_BATCH_SIZE, MAX_BATCH_SIZE].min
+      @max_queue_size = max_queue_size || DEFAULT_MAX_QUEUE_SIZE
+      @retry_max_attempts = retry_max_attempts || DEFAULT_RETRY_MAX_ATTEMPTS
+      @retry_initial_delay = retry_initial_delay || DEFAULT_RETRY_INITIAL_DELAY
+      @flush_on_shutdown = flush_on_shutdown.nil? ? true : flush_on_shutdown
+
+      @queue = Queue.new
+      @mutex = Mutex.new
+      @shutdown = false
+      @flush_in_progress = false
+      @flush_thread = nil
+
+      setup_shutdown_hook if @flush_on_shutdown
+      schedule_flush
+    end
+
+    # Track a user event
+    #
+    # @param event_name [String] Name of the event
+    # @param properties [Hash] Event properties (optional)
+    # @param user_id [String] User ID (optional)
+    # @param group_id [String] Group ID (optional)
+    # @param ip [String] IP address (optional)
+    # @return [void]
+    #
+    # @example Simple usage
+    #   client.track('Button Clicked', { button_name: 'Sign up' })
+    #
+    # @example With user context
+    #   client.track('Button Clicked', { button_name: 'Sign up' }, user_id: 'user_123', group_id: 'org_456')
+    def track(event_name, properties = nil, user_id: nil, group_id: nil, ip: nil)
+      return if @shutdown
+
+      event = Event.new(
+        type: EventType::TRACK,
+        event: event_name,
+        properties: properties || {},
+        user_id: user_id,
+        group_id: group_id,
+        context: build_context(ip)
+      )
+
+      enqueue(event)
+    end
+
+    # Identify a user with traits
+    #
+    # @param user_id [String] User ID (required)
+    # @param traits [Hash] User traits (optional)
+    # @param ip [String] IP address (optional)
+    # @return [void]
+    #
+    # @example
+    #   client.identify('user_123', { email: 'user@example.com', name: 'Stefan' })
+    def identify(user_id, traits = nil, ip: nil)
+      return if @shutdown
+
+      event = Event.new(
+        type: EventType::IDENTIFY,
+        user_id: user_id,
+        traits: traits || {},
+        context: build_context(ip)
+      )
+
+      enqueue(event)
+    end
+
+    # Associate a user with a group and set group traits
+    #
+    # @param group_id [String] Group ID (required)
+    # @param traits [Hash] Group traits (optional)
+    # @param user_id [String] User ID (optional)
+    # @param ip [String] IP address (optional)
+    # @return [void]
+    #
+    # @example Simple usage
+    #   client.group('org_456', { name: 'Acme Inc', plan: 'enterprise' })
+    #
+    # @example With user ID
+    #   client.group('org_456', { name: 'Acme Inc' }, user_id: 'user_123')
+    def group(group_id, traits = nil, user_id: nil, ip: nil)
+      return if @shutdown
+
+      event = Event.new(
+        type: EventType::GROUP,
+        group_id: group_id,
+        user_id: user_id,
+        traits: traits || {},
+        context: build_context(ip)
+      )
+
+      enqueue(event)
+    end
+
+    # Manually flush queued events immediately
+    #
+    # @return [void]
+    def flush
+      return if @shutdown
+
+      @mutex.synchronize do
+        return if @flush_in_progress
+
+        @flush_in_progress = true
+      end
+
+      begin
+        do_flush
+      ensure
+        @mutex.synchronize do
+          @flush_in_progress = false
+        end
+      end
+    end
+
+    # Gracefully shutdown the client, flushing remaining events
+    #
+    # @return [void]
+    def shutdown
+      return if @shutdown
+
+      @shutdown = true
+
+      # Cancel scheduled flush
+      @flush_thread&.kill
+
+      # Force flush remaining events (bypass normal flush which checks @shutdown)
+      flush_remaining
+    end
+
+    private
+
+    def setup_shutdown_hook
+      at_exit { shutdown }
+    end
+
+    def schedule_flush
+      return if @shutdown
+
+      @flush_thread = Thread.new do
+        sleep(@flush_interval / 1000.0)
+        flush unless @shutdown
+        schedule_flush unless @shutdown
+      end
+    end
+
+    def enqueue(event)
+      # Check event size
+      event_size = estimate_event_size(event)
+      if event_size > MAX_EVENT_SIZE_BYTES
+        warn "Klime: Event size (#{event_size} bytes) exceeds #{MAX_EVENT_SIZE_BYTES} bytes limit"
+        return
+      end
+
+      # Drop oldest if queue is full
+      @queue.pop(true) if @queue.size >= @max_queue_size rescue nil
+
+      @queue.push(event)
+
+      # Check if we should flush immediately
+      flush if @queue.size >= @max_batch_size
+    end
+
+    def do_flush
+      # Cancel any scheduled flush thread
+      @flush_thread&.kill
+
+      # Process batches
+      flush_remaining
+
+      # Schedule next flush
+      schedule_flush unless @shutdown
+    end
+
+    # Flush all queued events without scheduling (used by shutdown)
+    def flush_remaining
+      loop do
+        batch = extract_batch
+        break if batch.empty?
+
+        send_batch(batch)
+      end
+    end
+
+    def extract_batch
+      batch = []
+      batch_size = 0
+
+      while batch.length < MAX_BATCH_SIZE && batch.length < @max_batch_size
+        begin
+          event = @queue.pop(true) # non-blocking
+        rescue ThreadError
+          break # Queue is empty
+        end
+
+        event_size = estimate_event_size(event)
+
+        # Check if adding this event would exceed batch size limit
+        if batch_size + event_size > MAX_BATCH_SIZE_BYTES
+          # Put event back (at the front would be ideal, but Queue doesn't support that)
+          # We'll lose some ordering but it's acceptable for analytics
+          @queue.push(event)
+          break
+        end
+
+        batch << event
+        batch_size += event_size
+      end
+
+      batch
+    end
+
+    def send_batch(batch)
+      return if batch.empty?
+
+      request_body = { batch: batch.map(&:to_h) }.to_json
+      uri = URI.parse("#{@endpoint}/v1/batch")
+
+      attempt = 0
+      delay = @retry_initial_delay / 1000.0 # Convert to seconds
+
+      while attempt < @retry_max_attempts
+        begin
+          response = make_request(uri, request_body)
+
+          case response
+          when Net::HTTPSuccess
+            data = JSON.parse(response.body)
+            batch_response = BatchResponse.new(
+              status: data["status"] || "ok",
+              accepted: data["accepted"] || 0,
+              failed: data["failed"] || 0,
+              errors: parse_errors(data["errors"])
+            )
+
+            if batch_response.failed > 0 && batch_response.errors
+              warn "Klime: Batch partially failed. Accepted: #{batch_response.accepted}, Failed: #{batch_response.failed}"
+            end
+            return
+
+          when Net::HTTPBadRequest, Net::HTTPUnauthorized
+            data = JSON.parse(response.body) rescue {}
+            warn "Klime: Permanent error (#{response.code}): #{data}"
+            return
+
+          when Net::HTTPTooManyRequests, Net::HTTPServiceUnavailable
+            retry_after = response["Retry-After"]
+            delay = retry_after.to_i if retry_after && retry_after.to_i > 0
+
+            attempt += 1
+            if attempt < @retry_max_attempts
+              sleep(delay)
+              delay = [delay * 2, 16.0].min
+              next
+            end
+
+          else
+            # Other errors - retry
+            attempt += 1
+            if attempt < @retry_max_attempts
+              sleep(delay)
+              delay = [delay * 2, 16.0].min
+            end
+          end
+
+        rescue StandardError => e
+          # Network errors - retry
+          attempt += 1
+          if attempt < @retry_max_attempts
+            sleep(delay)
+            delay = [delay * 2, 16.0].min
+          else
+            warn "Klime: Failed to send batch after retries: #{e.message}"
+          end
+        end
+      end
+    end
+
+    def make_request(uri, body)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 10
+      http.read_timeout = 10
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{@write_key}"
+      request.body = body
+
+      http.request(request)
+    end
+
+    def build_context(ip = nil)
+      context = EventContext.new(
+        library: LibraryInfo.new(name: "ruby-sdk", version: VERSION)
+      )
+      context.ip = ip if ip
+      context
+    end
+
+    def estimate_event_size(event)
+      event.to_json.bytesize
+    rescue StandardError
+      500
+    end
+
+    def parse_errors(errors)
+      return nil unless errors.is_a?(Array)
+
+      errors.map do |err|
+        ValidationError.new(
+          index: err["index"] || -1,
+          message: err["message"] || "",
+          code: err["code"] || ""
+        )
+      end
+    end
+  end
+end
+

data/lib/klime/event.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "json"
+
+module Klime
+  # Event types supported by the API
+  module EventType
+    TRACK = "track"
+    IDENTIFY = "identify"
+    GROUP = "group"
+  end
+
+  # Library information included in event context
+  class LibraryInfo
+    attr_reader :name, :version
+
+    def initialize(name:, version:)
+      @name = name
+      @version = version
+    end
+
+    def to_h
+      {
+        name: @name,
+        version: @version
+      }
+    end
+  end
+
+  # Context information for events
+  class EventContext
+    attr_reader :library
+    attr_accessor :ip
+
+    def initialize(library: nil, ip: nil)
+      @library = library
+      @ip = ip
+    end
+
+    def to_h
+      result = {}
+      result[:library] = @library.to_h if @library
+      result[:ip] = @ip if @ip
+      result
+    end
+  end
+
+  # Base event class
+  class Event
+    attr_reader :type, :message_id, :timestamp, :context
+    attr_accessor :event, :user_id, :group_id, :properties, :traits
+
+    def initialize(
+      type:,
+      message_id: nil,
+      timestamp: nil,
+      event: nil,
+      user_id: nil,
+      group_id: nil,
+      properties: nil,
+      traits: nil,
+      context: nil
+    )
+      @type = type
+      @message_id = message_id || SecureRandom.uuid
+      @timestamp = timestamp || Time.now.utc.iso8601(3)
+      @event = event
+      @user_id = user_id
+      @group_id = group_id
+      @properties = properties
+      @traits = traits
+      @context = context
+    end
+
+    def to_h
+      result = {
+        type: @type,
+        messageId: @message_id,
+        timestamp: @timestamp
+      }
+
+      result[:event] = @event if @event
+      result[:userId] = @user_id if @user_id
+      result[:groupId] = @group_id if @group_id
+      result[:properties] = @properties if @properties
+      result[:traits] = @traits if @traits
+      result[:context] = @context.to_h if @context && !@context.to_h.empty?
+
+      result
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+
+  # Validation error from batch response
+  class ValidationError
+    attr_reader :index, :message, :code
+
+    def initialize(index:, message:, code:)
+      @index = index
+      @message = message
+      @code = code
+    end
+  end
+
+  # Batch response from the API
+  class BatchResponse
+    attr_reader :status, :accepted, :failed, :errors
+
+    def initialize(status:, accepted:, failed:, errors: nil)
+      @status = status
+      @accepted = accepted
+      @failed = failed
+      @errors = errors
+    end
+  end
+end
+

data/lib/klime/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Klime
+  VERSION = "1.0.4"
+end
+

data/lib/klime.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "klime/version"
+require_relative "klime/event"
+require_relative "klime/client"
+
+module Klime
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+end
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: klime
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+platform: ruby
+authors:
+- Klime
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Track events, identify users, and group them with organizations using
+  Klime analytics.
+email:
+- support@klime.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/klime.rb
+- lib/klime/client.rb
+- lib/klime/event.rb
+- lib/klime/version.rb
+homepage: https://github.com/klimeapp/klime-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/klimeapp/klime-ruby
+  source_code_uri: https://github.com/klimeapp/klime-ruby
+  documentation_uri: https://github.com/klimeapp/klime-ruby
+  changelog_uri: https://github.com/klimeapp/klime-ruby/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Klime SDK for Ruby
+test_files: []