Log

Renders one timeline entry with content, metadata, optional expandable details and action buttons.

Related components

Usage rules

• ✅ Use log_class + optional block to keep iconography and right badge consistent.
• ✅ Use from_any_source factories when converting backend payloads.
• ✅ If passing block, provide full shape { name:, kind:, url: }.
• ✅ Use with_expand / with_expand_content when you need details; it adds the expand button automatically.
• ✅ Prefer with_button(...) over with_button_manual(...) unless you need a custom render flow.
• ❌ Do not pass raw HTML from untrusted sources (prefer factory helpers and controlled content).

Description

The Log component is a versatile component for displaying individual log entries with rich content, expandable sections, and interactive elements. It's designed to work within the LogList component but can also be used standalone.

The component supports various content types including text with HTML formatting, entity tokens, expandable content, and action buttons.

Arguments

Slots

For content related:

• content (default slot). Supports rich text with HTML
• expand - Use via with_expand { ... } or with_expand_content(...); it auto-creates the "Show details" button.
• button - Use via with_button(...); renders LooposUi::Button.
• button_manual - Use via with_button_manual { ... } for custom/manual action rendering.
• source - Populates the right side of the Log. Has polymorphic options:
  • entity_token_source - Renders an EntityToken.
  • source - Alternative interface you can build an entity token and pass in as a parameter.
• title_token (polymorphic slot) Appears to the left of the log title.
  • Can render:
  • an EntityToken
  • an entity
  • manual content

block hash details

When passing block, use:

{
  name: "Validation",
  kind: "validation", # app/service/block kind
  url: "https://..."  # required when block is provided
}

kind is now mapped to current flow icons, including tool/decision kinds like tag, remove_tag, auto_validation, auto_accept_proposal, decision_*, as well as app kinds (core, submission, hubs, validation, handling).

Factory System

The Log component includes a factory system that allows automatic creation of Log components from various data sources. This system provides a consistent interface for converting different data types into Log components.

How It Works

The factory system automatically detects the appropriate factory for a given data source and uses it to create a Log component. This is done through the from_any_source class method:

log = LooposUi::Log.from_any_source(my_data_source)
# Note you can also use the desired factory directly
log = LooposUi::Log::Factories::CoreItemLogPresenterHash.create(my_data_source)
# or
log = LooposUi::Log::Factories::CoreItemLogPresenterHash.try_create(my_data_source)
# returns NilLog if the factory can't create the log in production
# raises error in development

from_any_source signature:

LooposUi::Log.from_any_source(source)

Implemented Factories

1. CoreItemLogPresenterHash

Purpose: Converts hash data from core item log presenters into Log components.

Data Source: Hash with the following structure:

{
  time: DateTime,
  author: String,
  app_instance: {
    name: String,
    kind: String
  },
  message: String,
  error: Boolean,
  log_class: String,      # optional
  title: String,          # optional
  extra_message: String,  # optional
  block: {                # optional (if present, must include all 3 keys)
    name: String,
    kind: String,
    url: String
  }
}

2. ScriptLog

Purpose: Converts LoopOs::ScriptLog objects into Log components.

Data Source: LoopOs::ScriptLog instances with properties like:

• created_at
• user_identification
• level
• name
• files
• input_data

Automatic Features:

• Download Button: Automatically added when files are present
• Retry Button: Automatically added when input_data is present and script is a ScriptProxy with retry capability
• Info Modal: Always included for detailed script information
• Retry Modal: Automatically created when retry button is present

Parameters:

• script: ScriptProxy object that provides retry functionality (optional, for retry button)

Example:

script_proxy = LoopOs::Scripts::ScriptProxy.new(@loop_os_script, context: {
  retry_path_proc: ->(script_log) { 
    rerun_script_script_path(@loop_os_script, script_log_id: script_log.id) 
  }
})
log = LooposUi::Log::Factories::ScriptLog.new(script_log, script: script_proxy).create

Creating Custom Factories

To create a custom factory, you need to:

Inherit from the base class:

class MyCustomFactory < LooposUi::Log::Factories::Base

Implement the can_create? class method:

def self.can_create?(source)
  # Return true if this factory can handle the given source
  source.is_a?(MyCustomModel)
end

Implement the create instance method:

def create
  LooposUi::Log.new(
    date: @source.created_at,
    user: @source.user_name,
    error: @source.error?
  ).with_content(@source.message)
end

Available Instance Variables in create method:

• @source - The original data source passed to the factory constructor
• @view_context - Available when using defer_render for complex rendering

Example: Number Factory

Here's a complete example from the dummy app showing how to create a simple factory:

module Factories
  class ExampleLogNumberFactory < LooposUi::Log::Factories::Base
    def self.can_create?(source)
      source.is_a?(Integer)
    end
    def create
      LooposUi::Log.new(
        # random time +- 5days
        date: Time.now + (3*@source).hours + 60.minutes - rand(60).minutes,
        user: "random LogNumberFactory #{@source}",
        error: rand > 0.9
      ).with_content("random message #{@source}")
    end
  end
end

Deferred Rendering

The factory create method must return a LooposUi::Log instance. But this runs before the component is rendered, so if you need to call for render, you need to use defer_render and call the view_context.render method.

def create
  log = LooposUi::Log.new(...)
  log.defer_render do |log, view_context|
    # Complex rendering logic here
    view_context.render( SomeComponent.new(...))
  end
  log
end

You have some helpers methods available if you want to build up the log incrementally:

• with_expand_content(content)

Note if you want to render HTML directly (e.g from a partial), you need to mark it as html_safe to avoid escaping.

Check for examples in the with_custom_expand example source code.