posthog-rails 3.5.0

data/lib/posthog/exception_capture.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Portions of this file are derived from getsentry/sentry-ruby by Software, Inc. dba Sentry
+# Licensed under the MIT License
+# - sentry-ruby/lib/sentry/interfaces/single_exception.rb
+# - sentry-ruby/lib/sentry/interfaces/stacktrace_builder.rb
+# - sentry-ruby/lib/sentry/backtrace.rb
+# - sentry-ruby/lib/sentry/interfaces/stacktrace.rb
+# - sentry-ruby/lib/sentry/linecache.rb
+
+# 💖 open source (under MIT License)
+
+module PostHog
+  module ExceptionCapture
+    RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in\s('|`)(?:([\w:]+)\#)?([^']+)')?$
+      /x
+
+    def self.build_parsed_exception(value)
+      title, message, backtrace = coerce_exception_input(value)
+      return nil if title.nil?
+
+      build_single_exception_from_data(title, message, backtrace)
+    end
+
+    def self.build_single_exception_from_data(title, message, backtrace)
+      {
+        'type' => title,
+        'value' => message || '',
+        'mechanism' => {
+          'type' => 'generic',
+          'handled' => true
+        },
+        'stacktrace' => build_stacktrace(backtrace)
+      }
+    end
+
+    def self.build_stacktrace(backtrace)
+      return nil unless backtrace && !backtrace.empty?
+
+      frames = backtrace.first(50).map do |line|
+        parse_backtrace_line(line)
+      end.compact.reverse
+
+      {
+        'type' => 'raw',
+        'frames' => frames
+      }
+    end
+
+    def self.parse_backtrace_line(line)
+      match = line.match(RUBY_INPUT_FORMAT)
+      return nil unless match
+
+      file = match[1]
+      lineno = match[2].to_i
+      method_name = match[5]
+
+      frame = {
+        'filename' => File.basename(file),
+        'abs_path' => file,
+        'lineno' => lineno,
+        'function' => method_name,
+        'in_app' => !gem_path?(file),
+        'platform' => 'ruby'
+      }
+
+      add_context_lines(frame, file, lineno) if File.exist?(file)
+
+      frame
+    end
+
+    def self.gem_path?(path)
+      path.include?('/gems/') ||
+        path.include?('/ruby/') ||
+        path.include?('/.rbenv/') ||
+        path.include?('/.rvm/')
+    end
+
+    def self.add_context_lines(frame, file_path, lineno, context_size = 5)
+      lines = File.readlines(file_path)
+      return if lines.empty?
+
+      return unless lineno.positive? && lineno <= lines.length
+
+      pre_context_start = [lineno - context_size, 1].max
+      post_context_end = [lineno + context_size, lines.length].min
+
+      frame['context_line'] = lines[lineno - 1].chomp
+
+      frame['pre_context'] = lines[(pre_context_start - 1)...(lineno - 1)].map(&:chomp) if pre_context_start < lineno
+
+      frame['post_context'] = lines[lineno...(post_context_end)].map(&:chomp) if post_context_end > lineno
+    rescue StandardError
+      # Silently ignore file read errors
+    end
+
+    def self.coerce_exception_input(value)
+      if value.is_a?(String)
+        title = 'Error'
+        message = value
+        backtrace = nil
+      elsif value.respond_to?(:backtrace) && value.respond_to?(:message)
+        title = value.class.to_s
+        message = value.message || ''
+        backtrace = value.backtrace
+      else
+        return [nil, nil, nil]
+      end
+
+      [title, message, backtrace]
+    end
+  end
+end

data/lib/posthog/feature_flag.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Represents a feature flag returned by /flags v2
+module PostHog
+  class FeatureFlag
+    attr_reader :key, :enabled, :variant, :reason, :metadata
+
+    def initialize(json)
+      json.transform_keys!(&:to_s)
+      @key = json['key']
+      @enabled = json['enabled']
+      @variant = json['variant']
+      @reason = json['reason'] ? EvaluationReason.new(json['reason']) : nil
+      @metadata = json['metadata'] ? FeatureFlagMetadata.new(json['metadata'].transform_keys(&:to_s)) : nil
+    end
+
+    # TODO: Rename to `value` in future version
+    def get_value # rubocop:disable Naming/AccessorMethodName
+      @variant || @enabled
+    end
+
+    def payload
+      @metadata&.payload
+    end
+
+    def self.from_value_and_payload(key, value, payload)
+      new({
+            'key' => key,
+            'enabled' => value.is_a?(String) || value,
+            'variant' => value.is_a?(String) ? value : nil,
+            'reason' => nil,
+            'metadata' => {
+              'id' => nil,
+              'version' => nil,
+              'payload' => payload,
+              'description' => nil
+            }
+          })
+    end
+  end
+
+  # Represents the reason why a flag was enabled/disabled
+  class EvaluationReason
+    attr_reader :code, :description, :condition_index
+
+    def initialize(json)
+      json.transform_keys!(&:to_s)
+      @code = json['code']
+      @description = json['description']
+      @condition_index = json['condition_index'].to_i if json['condition_index']
+    end
+  end
+
+  # Represents metadata about a feature flag
+  class FeatureFlagMetadata
+    attr_reader :id, :version, :payload, :description
+
+    def initialize(json)
+      json.transform_keys!(&:to_s)
+      @id = json['id']
+      @version = json['version']
+      @payload = json['payload']
+      @description = json['description']
+    end
+  end
+end

data/lib/posthog/feature_flag_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PostHog
+  # Error type constants for the $feature_flag_error property.
+  #
+  # These values are sent in analytics events to track flag evaluation failures.
+  # They should not be changed without considering impact on existing dashboards
+  # and queries that filter on these values.
+  #
+  # Error values:
+  #   ERRORS_WHILE_COMPUTING: Server returned errorsWhileComputingFlags=true
+  #   FLAG_MISSING: Requested flag not in API response
+  #   QUOTA_LIMITED: Rate/quota limit exceeded
+  #   TIMEOUT: Request timed out
+  #   CONNECTION_ERROR: Network connectivity issue
+  #   UNKNOWN_ERROR: Unexpected exceptions
+  #
+  # For API errors with status codes, use the api_error() method which returns
+  # a string like "api_error_500".
+  class FeatureFlagError
+    ERRORS_WHILE_COMPUTING = 'errors_while_computing_flags'
+    FLAG_MISSING = 'flag_missing'
+    QUOTA_LIMITED = 'quota_limited'
+    TIMEOUT = 'timeout'
+    CONNECTION_ERROR = 'connection_error'
+    UNKNOWN_ERROR = 'unknown_error'
+
+    # Generate API error string with status code.
+    #
+    # @param status [Integer, String] The HTTP status code
+    # @return [String] Error string in format "api_error_STATUS"
+    def self.api_error(status)
+      "api_error_#{status.to_s.downcase}"
+    end
+  end
+end

data/lib/posthog/feature_flag_result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PostHog
+  # Represents the result of a feature flag evaluation
+  # containing both the flag value and payload
+  class FeatureFlagResult
+    attr_reader :key, :variant, :payload
+
+    def initialize(key:, enabled:, variant: nil, payload: nil)
+      @key = key
+      @enabled = enabled
+      @variant = variant
+      @payload = payload
+    end
+
+    # Returns the effective value of the feature flag
+    # variant if present, otherwise enabled status
+    def value
+      @variant || @enabled
+    end
+
+    # Returns whether or not the feature flag evaluated as enabled
+    def enabled?
+      @enabled
+    end
+
+    # Factory method to create from flag value and payload
+    def self.from_value_and_payload(key, value, payload)
+      return nil if value.nil?
+
+      parsed_payload = parse_payload(payload)
+
+      if value.is_a?(String)
+        new(key: key, enabled: true, variant: value, payload: parsed_payload)
+      else
+        new(key: key, enabled: value, payload: parsed_payload)
+      end
+    end
+
+    def self.parse_payload(payload)
+      return nil if payload.nil?
+      return payload unless payload.is_a?(String)
+      return nil if payload.empty?
+
+      begin
+        JSON.parse(payload)
+      rescue JSON::ParserError
+        payload
+      end
+    end
+
+    private_class_method :parse_payload
+  end
+end