arrolio 0.1.1 → 0.1.2

data/lib/arrolio/generic_flow_builder.rb

@@ -5,7 +5,22 @@ require 'yaml'
 
 module Arrolio
   class GenericFlowBuilder
-    INLINE_SVG_PREFIX = 'inline-svg:'
+    autoload :Sequences, 'arrolio/generic_flow_builder/sequences'
+    autoload :Terms, 'arrolio/generic_flow_builder/terms'
+    autoload :Notes, 'arrolio/generic_flow_builder/notes'
+    autoload :Figures, 'arrolio/generic_flow_builder/figures'
+    autoload :Lists, 'arrolio/generic_flow_builder/lists'
+    autoload :Bibliography, 'arrolio/generic_flow_builder/bibliography'
+    autoload :Tables, 'arrolio/generic_flow_builder/tables'
+
+    include Sequences
+    include Terms
+    include Notes
+    include Figures
+    include Lists
+    include Bibliography
+    include Tables
+
 
     attr_reader :layout_spec, :rules, :asset_resolver
 
@@ -36,104 +51,14 @@ module Arrolio
       flowables
     end
 
-    def append_endnotes(document, flowables)
-      return if document.footnotes.empty?
-      return unless @rules['endnotes']
-
-      flowables << Flowables::PageSequenceStart.new(
-        role: :endnotes,
-        header_template: nil,
-        footer_template: nil
-      )
-      document.footnotes.each do |footnote|
-        marker_text = footnote.marker.to_s
-        body = footnote.body.map { |paragraph| paragraph_flowable(paragraph) }
-        flowables << Flowables::NoteFlowable.new(
-          marker_text,
-          body,
-          style: resolve(footnote.style_id),
-          marker_width: 22.0
-        )
-      end
-    end
 
     private
 
-    def page_sequences
-      Array(@rules['page_sequences'])
-    end
 
     def title_block_space
       (@rules.dig('title', 'block_space') || 0.0).to_f
     end
 
-    def sequence_start(document, sequence)
-      title = sequence['role'].to_s == 'body' ? title_text(document) : nil
-      Flowables::PageSequenceStart.new(
-        role: sequence.fetch('role'),
-        header_template: interpolate(sequence['header'], document),
-        footer_template: sequence['footer'],
-        header_align: sequence['header_align'],
-        footer_align: sequence['footer_align'] || :center,
-        initial_page_number: sequence['initial_page_number'],
-        title_template: title
-      )
-    end
-
-    def build_sequence_content(document, source, sequence, out)
-      if sequence['build_content'] == 'cover_content'
-        build_cover_content(document, out)
-      elsif source.is_a?(Array)
-        build_sections(source, out,
-                       between_breaks: preface_clause_breaks?(sequence))
-      end
-    end
-
-    # mn2pdf gives each preface clause its own page sequence (ToC
-    # page, then Foreword on a fresh page) when the flavor opts in.
-    def preface_clause_breaks?(sequence)
-      sequence['role'].to_s == 'preface' &&
-        @rules.dig('preface', 'page_break_between_clauses')
-    end
-
-    # The first body page opens with the part title ("Part 1 -
-    # {part title}") - the docidentifier's trailing part number
-    # supplies the prefix.
-    def title_text(document)
-      return nil unless document.title_block
-
-      text = document.title_block.inline_runs.map(&:text).join.strip
-      return nil if text.empty?
-
-      part = document.metadata[:docidentifier].to_s[/-(\d+)\z/, 1]
-      part ? "Part #{part} - #{text}" : text
-    end
-
-    def content_for(document, role)
-      case role.to_s
-      when 'preface' then document.preface
-      when 'body' then document.sections
-      when 'bibliography' then document.bibliography
-      else []
-      end
-    end
-
-    def build_cover_content(document, out)
-      Array(@rules['cover_content']).each do |entry|
-        next unless condition_matches?(entry['when'], document)
-
-        case entry['type'].to_s
-        when 'spacer'
-          out << Flowables::Spacer.new(entry.fetch('size').to_f)
-        when 'text'
-          style = resolve(entry.fetch('style'))
-          style = style.with(align: :center) if entry.fetch('align', 'center').to_sym == :center
-          text = interpolate(entry.fetch('source'), document)
-          out << Flowables::TextFlowable.new([InlineRun.new(text, style: style)], style: style)
-        end
-      end
-    end
-
     def build_sections(sections, out, between_breaks: false)
       section_rules = @rules.fetch('section', {})
       break_between = section_rules.fetch('insert_page_break_before', false)
@@ -265,230 +190,6 @@ module Arrolio
       end
     end
 
-    def note_flowable(note)
-      body = note.body.map { |node| note_body_flowable(node) }
-      body = with_note_body_spacing(body)
-      Flowables::NoteFlowable.new(
-        formatted_note_label(note.label),
-        body,
-        style: resolve(note.style_id),
-        label_style: resolve(:note_label)
-      )
-    end
-
-    # A note's trailing list sits ~7pt below its text in the
-    # reference (3.1.3.1: text -> list 20pt vs a plain 13pt pitch).
-    def with_note_body_spacing(body)
-      spacing = (@rules.dig('note', 'body_spacing') || 0.0).to_f
-      return body if spacing.zero? || body.length < 2
-
-      body.flat_map.with_index do |flowable, index|
-        index < body.length - 1 ? [flowable, Flowables::Spacer.new(spacing)] : [flowable]
-      end
-    end
-
-    def note_body_flowable(node)
-      return list_flowable(node, container: :note) if node.is_a?(Content::List)
-
-      paragraph_flowable(node)
-    end
-
-    def formatted_note_label(label)
-      return '' if label.nil? || label.empty?
-
-      suffix = @rules.dig('note', 'label_suffix') || ':'
-      stripped = label.strip.chomp(':').strip
-      return '' if stripped.empty?
-
-      suffix.start_with?(':') ? "#{stripped}#{suffix} " : "#{stripped} #{suffix} "
-    end
-
-    # Examples render the label as a block heading with the body
-    # indented 35.4pt — the FOP example layout.
-    def example_flowable(example)
-      body = example.body.map { |paragraph| paragraph_flowable(paragraph) }
-      Flowables::NoteFlowable.new(
-        example.label,
-        body,
-        style: resolve(example.style_id),
-        body_indent: 35.4,
-        label_mode: :block
-      )
-    end
-
-    # Figures are atomic: image + caption render as ONE flowable
-    # so the caption can never be orphaned onto the next page.
-    # Caption gap is flavor geometry (ref: image bottom to caption
-    # ~28pt; figure blocks separated by ~24pt).
-    def figure_group_flowable(group, out)
-      figure_config = @rules['figure'] || {}
-      caption_gap = figure_config.fetch('caption_gap', 0.0).to_f
-      block_gap = figure_config.fetch('block_gap', 0.0).to_f
-
-      image = image_flowable(group.image) if group.image
-      if group.caption
-        caption_style = resolve(:figure_caption).with(margin_top: caption_gap)
-        runs = group.caption.inline_runs.map do |run|
-          InlineRun.new(run.text, style: caption_style)
-        end
-        caption = Flowables::TextFlowable.new(runs, style: caption_style)
-      end
-      return out << caption if image.nil?
-
-      image = with_block_gap(image, block_gap)
-      out << if caption
-               Flowables::FigureFlowable.new(image, caption)
-             else
-               image
-             end
-    end
-
-    def with_block_gap(flowable, gap)
-      return flowable if gap.zero?
-
-      style = flowable.style.with(margin_top: flowable.style.margin_top + gap)
-      flowable.class.new(flowable.src,
-                         natural_width: flowable.natural_width,
-                         natural_height: flowable.natural_height,
-                         display_width: flowable.display_width,
-                         alt: flowable.alt,
-                         style: style)
-    end
-
-    # An entry's head must keep number + preferred + two
-    # definition lines together (the reference moves whole entry
-    # heads when those don't fit, leaving its characteristic
-    # 50-90pt terms-region page-end gaps).
-    def widen_first_definition_widows(out)
-      widows = term_config.fetch('definition_widows', 1).to_i
-      last = out.last
-      return unless widows > 1 && last.is_a?(Flowables::TextFlowable)
-
-      out[-1] = Flowables::TextFlowable.new(
-        last.runs,
-        style: last.style.with(widows: widows),
-        measurer: last.measurer
-      )
-    end
-
-    # Re-emits the last paragraph flowable with the configured
-    # between-sibling space (XSL-FO space-before semantics).
-    def apply_sibling_spacing(_item, out)
-      spacing = term_config.fetch('definition_paragraph_space_before', 0.0).to_f
-      return if spacing.zero? || out.empty?
-
-      last = out.last
-      return unless last.is_a?(Flowables::TextFlowable)
-
-      out[-1] = Flowables::TextFlowable.new(last.runs,
-                                            style: last.style.with(margin_top: spacing),
-                                            measurer: last.measurer)
-    end
-
-    def term_config
-      @rules['term'] || {}
-    end
-
-    def term_entry_flowable(entry, out)
-      if entry.number
-        number_style = resolve(:term).with(margin_top: 12.0, margin_bottom: 0.0)
-        out << Flowables::TextFlowable.new(
-          [InlineRun.new(entry.number, style: number_style)],
-          style: number_style
-        )
-      end
-      if entry.preferred
-        preferred_style = resolve(:term).with(margin_top: 0.0, margin_bottom: 6.0)
-        out << Flowables::TextFlowable.new(
-          entry.preferred.inline_runs.map do |run|
-            InlineRun.new(run.text, style: resolve(run.style_id),
-                                    baseline_shift: run.baseline_shift,
-                                    font_size_scale: run.font_size_scale,
-                                    href: run.href)
-          end,
-          style: preferred_style
-        )
-      end
-      # FOP applies space-before BETWEEN sibling blocks (not before
-      # the first) — term definitions' second+ paragraphs (the
-      # "(For notes...)" line) and the SOURCE line each carry it.
-      entry.definition.each_with_index do |item, index|
-        append_child(item, out, standalone: false, in_term: true)
-        if index.zero?
-          widen_first_definition_widows(out)
-        else
-          apply_sibling_spacing(item, out)
-        end
-      end
-      return unless entry.source
-
-      source_style = resolve(entry.source.style_id)
-                          .with(margin_top: term_config.fetch('source_space_before', 2.0).to_f,
-                                margin_bottom: 2.0)
-      source_runs = entry.source.inline_runs.map do |run|
-        InlineRun.new(run.text, style: resolve(run.style_id),
-                                baseline_shift: run.baseline_shift,
-                                font_size_scale: run.font_size_scale,
-                                href: run.href)
-      end
-      out << Flowables::TextFlowable.new(source_runs, style: source_style)
-    end
-
-    def bibliography_item_flowable(item, out)
-      tag = item.tag.to_s
-      body_para = bibliography_body_paragraph(item)
-      if tag.empty?
-        out << paragraph_flowable(body_para)
-        return
-      end
-
-      body = paragraph_flowable(body_para)
-      out << Flowables::NoteFlowable.new(
-        tag,
-        [body],
-        style: resolve(item.style_id || :bibitem),
-        label_style: resolve(:bibitem_marker),
-        marker_width: 24.0
-      )
-    end
-
-    def bibliography_body_paragraph(item)
-      runs = []
-      if item.formattedref
-        runs.concat(item.formattedref.inline_runs.map do |r|
-          Content::InlineRun.new(r.text, style_id: r.style_id)
-        end)
-      end
-      Content::Paragraph.new(runs, style_id: item.style_id || :bibitem,
-                                   id: item.id)
-    end
-
-    def marker_width_of(tag)
-      return 0.0 if tag.to_s.empty?
-
-      style = resolve(:bibitem_marker)
-      GlyphMeasurer.new(font_name: style.font_name)
-                   .width_of_string("#{tag} ", font_size: style.font_size)
-    end
-
-    def caption_runs_for(table)
-      return nil if table.caption.nil?
-
-      paragraph_flowable(table.caption, standalone: false).runs
-    end
-
-    # Table geometry (minimum row height, cell padding, footnote
-    # size) is flavor configuration — extracted from the flavor's
-    # XSL row/cell styles — not engine policy.
-    def table_geometry
-      config = @rules['table'] || {}
-      {
-        min_row_height: config.fetch('min_row_height', 0.0).to_f,
-        cell_padding: config.fetch('cell_padding', 2.0).to_f,
-        footnote_font_size: config['footnote_font_size']&.to_f
-      }
-    end
-
     def paragraph_flowable(paragraph, standalone: false)
       runs = paragraph.inline_runs.map do |run|
         InlineRun.new(
@@ -514,102 +215,6 @@ module Arrolio
       Flowables::TextFlowable.new(runs, style: style)
     end
 
-    def list_flowable(list, container: nil)
-      items = list.items.each_with_index.map do |item, index|
-        marker = item.marker.nil? ? default_marker(list, index, container: container) : item.marker
-        body = item.content.flat_map do |content|
-          flowable_for_list_content(content)
-        end
-        [marker, body]
-      end
-      Flowables::ListFlowable.new(items, kind: list.kind,
-                                         style: resolve(list.style_id),
-                                         **list_geometry(list.kind, container: container))
-    end
-
-    # List marker geometry (indent, marker column, inter-item
-    # spacing) is flavor configuration extracted from the flavor's
-    # XSL list styles — not engine policy.
-    # A kind-specific map (e.g. geometry.ordered) overrides the
-    # shared defaults — flavors whose bullets indent but whose
-    # ordered markers start at the margin (which also restores
-    # nested lists' depth).
-    def list_geometry(kind, container: nil)
-      config = @rules.dig('list', 'geometry') || {}
-      config = config.merge(config[kind.to_s] || {})
-      # Lists nested in note bodies sit deeper: the reference puts
-      # 3.1.3.1's note bullets at +43.7pt from the note column
-      # (marker x=143 from the page), pitch 17pt.
-      config = config.merge(@rules.dig('note', 'list') || {}) if container == :note
-      {
-        marker_indent: config.fetch('marker_indent', 0.0).to_f,
-        marker_width: config.fetch('marker_width', 18.0).to_f,
-        body_indent: config.fetch('body_indent', 6.0).to_f,
-        item_spacing: config.fetch('item_spacing', 0.0).to_f
-      }
-    end
-
-    def flowable_for_list_content(content)
-      case content
-      when Content::Paragraph then [paragraph_flowable(content)]
-      when Content::List then [list_flowable(content)]
-      else []
-      end
-    end
-
-    def default_marker(list, index, container: nil)
-      defaults = @rules.dig('list', 'defaults') || {}
-      if list.ordered?
-        format = defaults['ordered_marker'] || '%d.'
-        format.sub('%d', (index + 1).to_s)
-      else
-        nested = @rules.dig('note', 'list') || {}
-        return nested['bullet_marker'] if container == :note && nested['bullet_marker']
-
-        defaults['bullet_marker'] || '■ '
-      end
-    end
-
-    def image_flowable(image)
-      source = resolve_image_source(image)
-      image_rules = @rules['image'] || {}
-      default_width = (image_rules['default_natural_width'] || 400).to_f
-      default_height = (image_rules['default_natural_height'] || 300).to_f
-      max_width = (image_rules['max_display_width'] || 106).to_f
-      natural_width = image.width || svg_dimension(source, 'width') || default_width
-      natural_height = image.height || svg_dimension(source, 'height') || default_height
-      display_width = [image.width || natural_width, max_width].min
-      Flowables::ImageFlowable.new(
-        source,
-        natural_width: natural_width,
-        natural_height: natural_height,
-        display_width: display_width,
-        alt: image.alt,
-        style: resolve(image.style_id)
-      )
-    end
-
-    def resolve_image_source(image)
-      return asset_resolver.resolve(image.src) unless image.src.is_a?(String)
-      return write_inline_svg(image.src) if image.src.start_with?(INLINE_SVG_PREFIX)
-
-      asset_resolver.resolve(image.src)
-    end
-
-    def write_inline_svg(prefixed)
-      svg_xml = prefixed[INLINE_SVG_PREFIX.length..]
-      path = File.join(Dir.mktmpdir('arrolio-svg'), 'figure.svg')
-      File.write(path, svg_xml)
-      path
-    end
-
-    def svg_dimension(source, name)
-      return nil unless source && File.exist?(source) && source.match?(/\.svg\z/i)
-
-      value = File.read(source)[/(?:#{name})=["']([\d.]+)/, 1]
-      value && (value.to_f * SVG_PX_TO_PT)
-    end
-
     def resolve(style_id)
       @layout_spec.resolve_style(style_id.to_sym)
     end

data/lib/arrolio/renderer/pdf/assets.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module Assets
+        def register_logo(path)
+          return nil unless path
+
+          @document.images.add(path)
+        rescue StandardError => e
+          Arrolio::Logger.warn "logo load failed: #{e.class}: #{e.message[0, 80]}"
+          nil
+        end
+
+        def register_image(path)
+          return @images[path] if @images.key?(path)
+
+          resolved = resolve_image_for_pdfrb(path)
+          return nil unless resolved
+
+          @images[path] = @document.images.add(resolved)
+        rescue StandardError => e
+          Arrolio::Logger.warn "register_image failed for #{path}: #{e.class}: #{e.message[0, 80]}"
+          nil
+        end
+
+        # Pdfrb supports JPEG, PNG, and PDF — not SVG. If +path+ is an
+        # SVG file, rasterize it to PNG via rsvg-convert and cache the
+        # result. Returns the path to a pdfrb-compatible image file.
+        def resolve_image_for_pdfrb(path)
+          return path unless path.to_s.end_with?('.svg', '.SVG')
+          return path unless File.exist?(path)
+
+          png_path = svg_to_png_cache_path(path)
+          return png_path if File.exist?(png_path)
+
+          rasterize_svg(path, png_path)
+          File.exist?(png_path) ? png_path : path
+        end
+
+        def svg_to_png_cache_path(svg_path)
+          digest = Digest::MD5.file(svg_path).hexdigest
+          File.join(Dir.tmpdir, 'arrolio-svg-' + digest + '.png')
+        end
+
+        def rasterize_svg(svg_path, png_path)
+          require 'open3'
+          result = Open3.capture3('rsvg-convert', '-d', '96', '-p', '96',
+                                  '-o', png_path, svg_path)
+          return if result[2].success?
+
+          Arrolio::Logger.warn "rsvg-convert failed: #{result[1]}"
+        rescue StandardError => e
+          Arrolio::Logger.warn "rasterize_svg failed: #{e.class}: #{e.message[0, 80]}"
+        end
+
+        def cover_logo_style
+          return @cover_logo_style if @cover_logo_style
+
+          config = @layout_spec&.cover_logo_config || {}
+          width_mm = config['width_mm'] || 35.0
+          ratio = config['aspect_ratio'] || (1459.0 / 1667.0)
+          margin_mm = config['margin_mm'] || 25.5
+          @cover_logo_style = {
+            width: width_mm * MM_TO_PT,
+            height: width_mm * ratio * MM_TO_PT,
+            margin: margin_mm * MM_TO_PT
+          }.freeze
+        end
+
+        def render_cover_logo(canvas, page)
+          logo_style = cover_logo_style
+          w = logo_style[:width]
+          h = logo_style[:height]
+          margin = logo_style[:margin]
+          x = page.width - margin - w
+          y = page.height - margin - h
+          invoke = invoke_xobject_op
+          return unless invoke
+
+          canvas.save_graphics_state do
+            canvas.concat(w, 0, 0, h, x, y)
+            canvas.emit_op(invoke, @logo_ref)
+          end
+        rescue StandardError => e
+          Arrolio::Logger.warn "logo render failed: #{e.class}: #{e.message[0, 80]}"
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/pdf/font_embedding.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module FontEmbedding
+        # Pre-scan all pages, collect codepoints per font family,
+        # then call Font::Embedder for each font_path.
+        def prepare_embedded_fonts(pages)
+          return if @font_paths.empty?
+
+          codepoints = Hash.new { |h, k| h[k] = [] }
+          pages.each { |page| collect_codepoints(page, codepoints) }
+          Arrolio::Logger.debug "collected codepoints for fonts: #{codepoints.keys.inspect}"
+          @font_paths.each do |font_name, path|
+            exists = File.exist?(path)
+            has_cp = codepoints.key?(font_name)
+            cp_count = codepoints[font_name]&.length || 0
+            Arrolio::Logger.debug "font #{font_name}: exists=#{exists} cp=#{cp_count}"
+            next unless exists
+            next unless has_cp
+
+            cps = codepoints[font_name].uniq
+            embedder = Font::Embedder.new(@document, path,
+                                          base_font_name: font_name)
+            ref = embedder.embed(cps)
+            attach_to_resources(font_name, ref)
+            @font_embedders[font_name] = embedder
+            @font_encoders[font_name] = Font::TextEncoder.new(embedder)
+            @font_refs[font_name] = ref
+          rescue StandardError => e
+            Arrolio::Logger.warn "embed failed for #{font_name}: #{e.class}: #{e.message[0,100]}"
+            Arrolio::Logger.debug e.backtrace.first(5).join("\n")
+          end
+        end
+
+        def attach_to_resources(font_name, ref)
+          catalog = @document.catalog
+          res = catalog.value[:Resources]
+          Arrolio::Logger.debug "attach_to_resources: Resources=#{res.class}"
+          unless res.is_a?(Hash) && res[:Font].is_a?(Hash)
+            catalog.value[:Resources] = { Font: {} }
+          end
+          font_hash = catalog.value[:Resources][:Font]
+          key = (format('EF%d', (font_hash.length + 1))).to_sym
+          font_hash[key] = ref
+          @embedded_resource_keys ||= {}
+          @embedded_resource_keys[font_name] = key
+        end
+
+        def collect_codepoints(page, by_font)
+          (page.static_regions.values + page.regions.values).each do |region|
+            region.placed_boxes.each do |box|
+              next unless box.kind == :text
+              next unless box.data.is_a?(Hash) && box.data[:lines]
+
+              box.data[:lines].each do |line|
+                next unless line.is_a?(TextLayout::Line)
+                line.placed_runs.each do |pr|
+                  next unless pr.run.is_a?(InlineRun)
+                  # Collect under the RUN'S font name, not the
+                  # paragraph's. Italic/bold runs have different
+                  # font_names and need their own subsets.
+                  run_font = pr.run.style.font_name
+                  next unless @font_paths.key?(run_font)
+                  pr.run.text.each_codepoint { |cp| by_font[run_font] << cp }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/pdf/metadata.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module Metadata
+        def apply_metadata(metadata)
+          info = @document.catalog.value[:Info]
+          info ||= @document.add({})
+          @document.catalog.value[:Info] = info
+          info.value[:Title] = metadata[:title] if metadata[:title]
+          info.value[:Author] = metadata[:author] if metadata[:author]
+          info.value[:Creator] = 'Arrolio (Ruby)'
+          info.value[:Producer] = 'Arrolio + Pdfrb'
+        end
+
+        # Emit an XMP metadata packet (RDF/XML) as a stream on the
+        # catalog's /Metadata entry. PDF readers use this for Dublin
+        # Core properties alongside the legacy /Info dict.
+        def attach_xmp_metadata(metadata)
+          xmp = XmpBuilder.new(metadata).build
+          stream = @document.add(
+            { Type: :Metadata, Subtype: :XML, Length: xmp.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          stream.stream = xmp
+          @document.catalog.value[:Metadata] =
+            Pdfrb::Model::Reference.new(stream.oid, stream.gen)
+        rescue StandardError => e
+          Arrolio::Logger.warn "XMP attach failed: #{e.class}: #{e.message[0, 80]}"
+        end
+
+        def build_outline(context, _pages)
+          entries = context.heading_entries
+          return unless entries&.any?
+
+          pdfrb_pages = @document.pages.to_a
+          ob = OutlineBuilder.new(document: @document,
+                                  entries: entries,
+                                  pdfrb_pages: pdfrb_pages)
+          result = ob.build
+          Arrolio::Logger.debug "outline build returned: #{result.class}"
+        rescue StandardError => e
+          Arrolio::Logger.warn "outline build failed: #{e.class}: #{e.message[0,150]}"
+          Arrolio::Logger.debug e.backtrace.first(5).join("\n")
+        end
+      end
+    end
+  end
+end