{
  "resource_name": "Api::V1::EditingsController#show",
  "service": "cupixworks-api",
  "occurrences": 1,
  "avg_ms": 1580,
  "max_ms": 1580,
  "sample_trace_id": "4471223273264767489"
}

def default_joins(record)
  record.left_joins(:level, :workspace, :facility, :team, :category, :workarea)
        .joins("
     LEFT JOIN users ON users.id = editings.user_id
     LEFT JOIN users AS editor ON editor.id = editings.editor_id
     LEFT JOIN users AS escalated_by ON escalated_by.id = editings.escalated_by_id
  ").select('
    editings.*,
    levels.name AS level_name,
    workspaces.name AS workspace_name,
    facilities.name AS facility_name,
    facilities.key AS facility_key,
    teams.name AS team_name,
    users.firstname AS user_firstname,
    users.lastname AS user_lastname,
    users.email AS user_email,
    editor.firstname AS editor_firstname,
    editor.lastname AS editor_lastname,
    editor.email AS editor_email,
    escalated_by.firstname AS escalated_by_firstname,
    escalated_by.lastname AS escalated_by_lastname,
    escalated_by.email AS escalated_by_email
  ')
end

scope = current_class.visibility_scope(visibility)
model = query.merge(scope).first

if model.nil? && current_user.present? && current_user.team.domain == 'admin'
  unless (::UserRepository.new(model: current_user).group_codes & %w[administrator senior_editing_engineers]).empty?
    model = self.where(attrs).merge(scope).first
  end
end

attribute :user, &:_user
attribute :editor, &:_editor
attribute :escalated_by, &:_escalated_by
include TeamAttribute
include WorkspaceAttribute
include FacilityAttribute
attribute :record, &:_record
attribute :level, &:_level
attribute :category, &:_category
attribute :workarea, &:_workarea

define_method "_#{name}" do |*args, **kwargs, &block|
  if options[:polymorphic]
    fetch_cache(send("#{name}_type"), send("#{name}_id")).merge({
      type: send("#{name}_type")
    }) rescue nil
  else
    model_name = options[:class_name] || name
    model_id = options[:foreign_key] || "#{name}_id"
    fetch_cache(model_name.to_s.classify, send(model_id))
  end
end

def fetch_cache(model_name = self.class.name, model_id = self.id)
  return nil if model_id.blank?

  Rails.cache.fetch(cache_key(model_name, model_id), skip_nil: true, expires_in: self.class.cache_expires_in) do
    if self.respond_to?("serialized_#{model_name.underscore}_json".to_sym)
      self.send("serialized_#{model_name.underscore}_json")
    else
      record = model_name.constantize.find_by_id(model_id)
      record.serialized_json if record.respond_to?(:serialized_json)
    end
  end
end

def statistic_to_json
  stats = all_statistic

  {
    editing: _editing_stat_json(stats),
    count: _count_stat_json
  }
end

def all_statistic
  return @preloaded_all_statistic if defined?(@preloaded_all_statistic)

  statistics.group(:name, :phase)
            .maximum(:created_at)
            .transform_values(&:to_datetime)
end

Datadog query: service:cupixworks-api "EditingsController#show" from:2026-05-27T09:00:00Z to:2026-05-27T09:40:00Z

2026-05-27 18:39:59 [info] [200] GET /api/v1/editings/1122918 (Api::V1::EditingsController#show)
2026-05-27 18:39:37 [info] [200] GET /api/v1/editings/1122917 (Api::V1::EditingsController#show)
2026-05-27 18:38:41 [info] [200] GET /api/v1/editings/1122916 (Api::V1::EditingsController#show)
2026-05-27 18:37:39 [info] [200] GET /api/v1/editings/189520 (Api::V1::EditingsController#show)

Datadog query: service:cupixworks-api "EditingsController" status:error from:2026-05-27T08:00:00Z to:2026-05-27T10:30:00Z

service:cupixworks-api resource_name:"Api::V1::EditingsController#show" @duration:>1000ms env:production