rubyllm-observ 0.5.0

data/app/services/observ/trace_text_formatter.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+module Observ
+  class TraceTextFormatter
+    SEPARATOR = "=" * 80
+    SUBSEPARATOR = "-" * 80
+    INDENT = "  "
+    MAX_CONTENT_LENGTH = 10_000
+
+    attr_reader :trace
+
+    def initialize(trace)
+      @trace = trace
+    end
+
+    # Main public method to format the trace as plain text
+    def format
+      parts = []
+      parts << format_trace_header
+      parts << format_trace_details
+      parts << format_trace_annotations if trace.annotations.any?
+      parts << ""
+      parts << format_observations_section
+      parts << SEPARATOR
+      parts.join("\n")
+    end
+
+    private
+
+    def format_trace_header
+      [
+        SEPARATOR,
+        "TRACE: #{trace.name || 'Unnamed Trace'}",
+        SEPARATOR
+      ].join("\n")
+    end
+
+    def format_trace_details
+      details = []
+      details << "Trace ID: #{trace.trace_id}"
+      details << "Start Time: #{format_time(trace.start_time)}"
+      details << "End Time: #{format_time(trace.end_time)}" if trace.end_time
+      details << "Duration: #{format_duration(trace.duration_ms)}" if trace.duration_ms
+      details << "Total Cost: #{format_cost(trace.total_cost)}" if trace.total_cost && trace.total_cost > 0
+      details << "Total Tokens: #{trace.total_tokens}" if trace.total_tokens && trace.total_tokens > 0
+
+      if trace.user_id.present?
+        details << "User ID: #{trace.user_id}"
+      end
+
+      if trace.release.present?
+        details << "Release: #{trace.release}"
+      end
+
+      if trace.version.present?
+        details << "Version: #{trace.version}"
+      end
+
+      if trace.input.present?
+        details << ""
+        details << "Input:"
+        details << format_content(trace.input)
+      end
+
+      if trace.output.present?
+        details << ""
+        details << "Output:"
+        details << format_content(trace.output)
+      end
+
+      if trace.metadata.present? && trace.metadata.any?
+        details << ""
+        details << "Metadata:"
+        details << format_json(trace.metadata)
+      end
+
+      if trace.tags.present? && trace.tags.any?
+        details << ""
+        details << "Tags: #{trace.tags.to_json}"
+      end
+
+      details.join("\n")
+    end
+
+    def format_trace_annotations
+      annotations = trace.annotations.order(created_at: :asc)
+      return "" if annotations.empty?
+
+      parts = []
+      parts << ""
+      parts << "--- ANNOTATIONS (#{annotations.count}) ---"
+
+      annotations.each do |annotation|
+        parts << format_annotation(annotation)
+      end
+
+      parts.join("\n")
+    end
+
+    def format_observations_section
+      observations = trace.observations.order(start_time: :asc)
+      return "No observations recorded." if observations.empty?
+
+      parts = []
+      parts << SEPARATOR
+      parts << "OBSERVATIONS (#{observations.count})"
+      parts << SEPARATOR
+      parts << ""
+
+      # Build tree structure
+      observations_by_parent = observations.group_by(&:parent_observation_id)
+      root_observations = observations_by_parent[nil] || []
+
+      root_observations.each do |observation|
+        parts << format_observation(observation, observations_by_parent, 0)
+        parts << ""
+      end
+
+      parts.join("\n")
+    end
+
+    def format_observation(observation, observations_by_parent, depth)
+      indent = INDENT * depth
+      parts = []
+
+      # Observation header
+      parts << "#{indent}┌─ [#{observation.type.demodulize.upcase}] #{observation.name}"
+      parts << "#{indent}│  Observation ID: #{observation.observation_id}"
+      parts << "#{indent}│  Start: #{format_time(observation.start_time)}"
+      parts << "#{indent}│  End: #{format_time(observation.end_time)}" if observation.end_time
+      parts << "#{indent}│  Duration: #{format_duration(observation.duration_ms)}" if observation.duration_ms
+
+      # Type-specific formatting
+      if observation.is_a?(Observ::Generation)
+        parts << format_generation_details(observation, indent)
+      elsif observation.is_a?(Observ::Span)
+        parts << format_span_details(observation, indent)
+      end
+
+      parts << "#{indent}└─ End of #{observation.type.demodulize.upcase}"
+
+      # Recursively format child observations
+      children = observations_by_parent[observation.observation_id] || []
+      if children.any?
+        parts << ""
+        parts << "#{indent}  ┌─ CHILD OBSERVATIONS (#{children.count})"
+        children.each do |child|
+          parts << format_observation(child, observations_by_parent, depth + 1)
+        end
+        parts << "#{indent}  └─ END CHILD OBSERVATIONS"
+      end
+
+      parts.join("\n")
+    end
+
+    def format_generation_details(generation, indent)
+      details = []
+
+      if generation.model.present?
+        details << "#{indent}│  Model: #{generation.model}"
+      end
+
+      if generation.cost_usd && generation.cost_usd > 0
+        details << "#{indent}│  Cost: #{format_cost(generation.cost_usd)}"
+      end
+
+      if generation.usage.present? && generation.usage.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Usage:"
+        generation.usage.each do |key, value|
+          details << "#{indent}│    - #{key.to_s.humanize}: #{value}"
+        end
+      end
+
+      if generation.model_parameters.present? && generation.model_parameters.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Model Parameters:"
+        generation.model_parameters.each do |key, value|
+          details << "#{indent}│    - #{key}: #{value}"
+        end
+      end
+
+      if generation.prompt_name.present?
+        details << "#{indent}│  Prompt Name: #{generation.prompt_name}"
+        details << "#{indent}│  Prompt Version: #{generation.prompt_version}" if generation.prompt_version.present?
+      end
+
+      if generation.finish_reason.present?
+        details << "#{indent}│  Finish Reason: #{generation.finish_reason}"
+      end
+
+      if generation.status_message.present?
+        details << "#{indent}│  Status: #{generation.status_message}"
+      end
+
+      if generation.messages.present? && generation.messages.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Messages:"
+        generation.messages.each_with_index do |msg, idx|
+          details << "#{indent}│    [#{idx + 1}] #{msg['role']}: #{truncate_content(msg['content'], 200)}"
+        end
+      end
+
+      if generation.tools.present? && generation.tools.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Tools Available: #{generation.tools.count}"
+        generation.tools.first(3).each do |tool|
+          tool_name = tool.is_a?(Hash) ? tool["name"] || tool[:name] : tool.to_s
+          details << "#{indent}│    - #{tool_name}"
+        end
+        details << "#{indent}│    ... and #{generation.tools.count - 3} more" if generation.tools.count > 3
+      end
+
+      if generation.input.present?
+        details << "#{indent}│  "
+        details << "#{indent}│  Input:"
+        format_content(generation.input).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      if generation.output.present?
+        details << "#{indent}│  "
+        details << "#{indent}│  Output:"
+        format_content(generation.output).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      if generation.metadata.present? && generation.metadata.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Metadata:"
+        format_json(generation.metadata).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      if generation.provider_metadata.present? && generation.provider_metadata.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Provider Metadata:"
+        format_json(generation.provider_metadata).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      details.join("\n")
+    end
+
+    def format_span_details(span, indent)
+      details = []
+
+      if span.status_message.present?
+        details << "#{indent}│  Status: #{span.status_message}"
+      end
+
+      if span.input.present?
+        details << "#{indent}│  "
+        details << "#{indent}│  Input:"
+        format_content(span.input).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      if span.output.present?
+        details << "#{indent}│  "
+        details << "#{indent}│  Output:"
+        format_content(span.output).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      if span.metadata.present? && span.metadata.any?
+        details << "#{indent}│  "
+        details << "#{indent}│  Metadata:"
+        format_json(span.metadata).split("\n").each do |line|
+          details << "#{indent}│  #{line}"
+        end
+      end
+
+      details.join("\n")
+    end
+
+    def format_annotation(annotation, prefix = "")
+      parts = []
+      timestamp = format_time(annotation.created_at)
+
+      if annotation.annotator.present?
+        parts << "#{prefix}[#{timestamp}] #{annotation.annotator}"
+      else
+        parts << "#{prefix}[#{timestamp}]"
+      end
+
+      parts << "#{prefix}#{annotation.content}"
+
+      if annotation.tags.present? && annotation.tags.any?
+        parts << "#{prefix}Tags: #{annotation.tags.to_json}"
+      end
+
+      parts << ""
+      parts.join("\n")
+    end
+
+    def format_time(time)
+      return "N/A" unless time
+      time.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+    end
+
+    def format_duration(duration_ms)
+      return "N/A" unless duration_ms
+      "#{duration_ms}ms"
+    end
+
+    def format_cost(cost)
+      return "$0.000000" unless cost
+      "$#{sprintf('%.6f', cost)}"
+    end
+
+    def format_content(content)
+      return "" if content.blank?
+
+      # Try to parse as JSON for pretty printing
+      if content.is_a?(String)
+        begin
+          parsed = JSON.parse(content)
+          return format_json(parsed)
+        rescue JSON::ParserError
+          # Not JSON, return as-is
+        end
+      end
+
+      truncate_content(content.to_s)
+    end
+
+    def format_json(obj)
+      JSON.pretty_generate(obj)
+    rescue StandardError
+      obj.to_s
+    end
+
+    def truncate_content(content, max_length = MAX_CONTENT_LENGTH)
+      return "" if content.blank?
+
+      content_str = content.to_s
+      return content_str if content_str.length <= max_length
+
+      "#{content_str[0...max_length]}...\n[Content truncated, original length: #{content_str.length} characters]"
+    end
+  end
+end

data/app/validators/observ/prompt_config_validator.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Observ
+  class PromptConfigValidator
+    attr_reader :config, :errors
+
+    def initialize(config)
+      @config = config
+      @errors = []
+    end
+
+    def valid?
+      @errors = []
+
+      return true if config.blank?
+
+      unless config.is_a?(Hash)
+        @errors << "Config must be a Hash"
+        return false
+      end
+
+      validate_against_schema
+      @errors.empty?
+    end
+
+    private
+
+    def validate_against_schema
+      schema.each do |key, rules|
+        value, raw_key = value_with_key(key)
+
+        # Check required fields
+        if rules[:required] && value.nil?
+          @errors << "#{key} is required"
+          next
+        end
+
+        # Skip validation if value is nil and not required
+        next if value.nil?
+
+        # Coerce values like numeric strings before validation
+        coerced_value = coerce_value(value, rules[:type])
+        assign_value(raw_key, coerced_value) if raw_key && coerced_value != value
+        value = coerced_value
+
+        # Validate type
+        validate_type(key, value, rules)
+
+        # Validate range if specified
+        validate_range(key, value, rules) if rules[:range]
+
+        # Validate allowed values if specified
+        validate_allowed_values(key, value, rules) if rules[:allowed]
+
+        # Validate array items if specified
+        validate_array_items(key, value, rules) if rules[:item_type]
+      end
+
+      # Check for unknown keys
+      validate_unknown_keys if schema_strict?
+    end
+
+    def validate_type(key, value, rules)
+      expected_type = rules[:type]
+
+      case expected_type
+      when :integer
+        unless value.is_a?(Integer)
+          @errors << "#{key} must be an integer"
+        end
+      when :float
+        unless value.is_a?(Numeric)
+          @errors << "#{key} must be a number"
+        end
+      when :string
+        unless value.is_a?(String)
+          @errors << "#{key} must be a string"
+        end
+      when :boolean
+        unless [ true, false ].include?(value)
+          @errors << "#{key} must be a boolean"
+        end
+      when :array
+        unless value.is_a?(Array)
+          @errors << "#{key} must be an array"
+        end
+      when :hash
+        unless value.is_a?(Hash)
+          @errors << "#{key} must be a hash"
+        end
+      end
+    end
+
+    def validate_range(key, value, rules)
+      range = rules[:range]
+
+      return unless value.is_a?(Numeric)
+
+      unless range.cover?(value)
+        @errors << "#{key} must be between #{range.min} and #{range.max}"
+      end
+    end
+
+    def validate_allowed_values(key, value, rules)
+      allowed = rules[:allowed]
+
+      unless allowed.include?(value)
+        @errors << "#{key} must be one of: #{allowed.join(', ')}"
+      end
+    end
+
+    def validate_array_items(key, value, rules)
+      return unless value.is_a?(Array)
+
+      item_type = rules[:item_type]
+
+      value.each_with_index do |item, index|
+        case item_type
+        when :string
+          unless item.is_a?(String)
+            @errors << "#{key}[#{index}] must be a string"
+          end
+        when :integer
+          unless item.is_a?(Integer)
+            @errors << "#{key}[#{index}] must be an integer"
+          end
+        when :float
+          unless item.is_a?(Numeric)
+            @errors << "#{key}[#{index}] must be a number"
+          end
+        end
+      end
+    end
+
+    def validate_unknown_keys
+      schema_keys = schema.keys.map { |k| [ k.to_s, k.to_sym ] }.flatten
+      config_keys = config.keys
+
+      unknown_keys = config_keys - schema_keys
+
+      if unknown_keys.any?
+        @errors << "Unknown configuration keys: #{unknown_keys.join(', ')}"
+      end
+    end
+
+    def schema
+      @schema ||= Observ.config.prompt_config_schema
+    end
+
+    def schema_strict?
+      Observ.config.prompt_config_schema_strict
+    end
+
+    def value_with_key(key)
+      if config.key?(key.to_s)
+        [ config[key.to_s], key.to_s ]
+      elsif config.key?(key.to_sym)
+        [ config[key.to_sym], key.to_sym ]
+      else
+        [ nil, nil ]
+      end
+    end
+
+    def assign_value(raw_key, value)
+      return unless raw_key
+      config[raw_key] = value
+    end
+
+    def coerce_value(value, expected_type)
+      case expected_type
+      when :integer
+        return value.to_i if integer_string?(value)
+      when :float
+        return value.to_f if numeric_string?(value)
+      end
+      value
+    end
+
+    def integer_string?(value)
+      value.is_a?(String) && value.match?(/\A-?\d+\z/)
+    end
+
+    def numeric_string?(value)
+      value.is_a?(String) && value.match?(/\A-?\d+(?:\.\d+)?\z/)
+    end
+  end
+end

data/app/views/kaminari/_first_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "First" page
+  - available local variables
+    url:           url to the first page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="first">
+  <%= link_to_unless current_page.first?, t('views.pagination.first').html_safe, url, remote: remote %>
+</span>

data/app/views/kaminari/_gap.html.erb

@@ -0,0 +1,8 @@
+<%# Non-link tag that stands for skipped pages...
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page gap"><%= t('views.pagination.truncate').html_safe %></span>

data/app/views/kaminari/_last_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Last" page
+  - available local variables
+    url:           url to the last page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="last">
+  <%= link_to_unless current_page.last?, t('views.pagination.last').html_safe, url, remote: remote %>
+</span>

data/app/views/kaminari/_next_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Next" page
+  - available local variables
+    url:           url to the next page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="next">
+  <%= link_to_unless current_page.last?, t('views.pagination.next').html_safe, url, rel: 'next', remote: remote %>
+</span>

data/app/views/kaminari/_page.html.erb

@@ -0,0 +1,12 @@
+<%# Link showing page number
+  - available local variables
+    page:          a page object for "this" page
+    url:           url to this page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page<%= ' current' if page.current? %>">
+  <%= link_to_unless page.current?, page, url, {remote: remote, rel: page.rel} %>
+</span>

data/app/views/kaminari/_paginator.html.erb

@@ -0,0 +1,25 @@
+<%# The container tag
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+    paginator:     the paginator that renders the pagination tags inside
+-%>
+<%= paginator.render do -%>
+  <nav class="pagination" role="navigation" aria-label="pager">
+    <%= first_page_tag unless current_page.first? %>
+    <%= prev_page_tag unless current_page.first? %>
+    <% each_page do |page| -%>
+      <% if page.display_tag? -%>
+        <%= page_tag page %>
+      <% elsif !page.was_truncated? -%>
+        <%= gap_tag %>
+      <% end -%>
+    <% end -%>
+    <% unless current_page.out_of_range? %>
+      <%= next_page_tag unless current_page.last? %>
+      <%= last_page_tag unless current_page.last? %>
+    <% end %>
+  </nav>
+<% end -%>

data/app/views/kaminari/_prev_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Previous" page
+  - available local variables
+    url:           url to the previous page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="prev">
+  <%= link_to_unless current_page.first?, t('views.pagination.previous').html_safe, url, rel: 'prev', remote: remote %>
+</span>

data/app/views/kaminari/observ/_first_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "First" page
+  - available local variables
+    url:           url to the first page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="first">
+  <%= link_to_unless current_page.first?, t('views.pagination.first').html_safe, url, remote: remote %>
+</span>

data/app/views/kaminari/observ/_gap.html.erb

@@ -0,0 +1,8 @@
+<%# Non-link tag that stands for skipped pages...
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page gap"><%= t('views.pagination.truncate').html_safe %></span>

data/app/views/kaminari/observ/_last_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Last" page
+  - available local variables
+    url:           url to the last page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="last">
+  <%= link_to_unless current_page.last?, t('views.pagination.last').html_safe, url, remote: remote %>
+</span>

data/app/views/kaminari/observ/_next_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Next" page
+  - available local variables
+    url:           url to the next page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="next">
+  <%= link_to_unless current_page.last?, t('views.pagination.next').html_safe, url, rel: 'next', remote: remote %>
+</span>

data/app/views/kaminari/observ/_page.html.erb

@@ -0,0 +1,12 @@
+<%# Link showing page number
+  - available local variables
+    page:          a page object for "this" page
+    url:           url to this page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page<%= ' current' if page.current? %>">
+  <%= link_to_unless page.current?, page, url, {remote: remote, rel: page.rel} %>
+</span>