b3c4a532-5da0-46f8-9c20-20018605a028

Committed 21 Mar 2025 08:11PM UTC coverage: 42.257% (-49.9%) from 92.185%

Build # b3c4a532-5da0-46f8-9c20-20018605a028

Build Type

push

circleci

Committed by

sandbergja

Commit Message

Move various gems from the default Gemfile group to a more appropriate group

Run Details

1599 of 3784 relevant lines covered (42.26%)

2.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

29.51

/app/services/aws_sqs_poller.rb

# This service is intended to be run by a daemon. It watches the AWS SQS poll
# for full dump events and kicks off a job to process them.
class AwsSqsPoller
  def self.poll
    queue_url = Rails.configuration.alma['sqs_queue_url']
    poller = Aws::SQS::QueuePoller.new(queue_url)
    end_polling = false

    # End polling if the process is killed by restarting.
    Signal.trap('TERM') do
      end_polling = true
    end

    poller.after_empty_receive do |stats|
      Rails.logger.info("AWS SQS Poller after_empty_receive request_count: #{stats.request_count}")
      Rails.logger.info("AWS SQS Poller after_empty_receive received_message_count: #{stats.received_message_count}")
      Rails.logger.info("AWS SQS Poller after_empty_receive last_message_received_at: #{stats.last_message_received_at}")
    end

    poller.before_request do |stats|
      Rails.logger.info("AWS SQS Poller before_request request_count: #{stats.request_count}")
      Rails.logger.info("AWS SQS Poller before_request message_count: #{stats.received_message_count}")
      Rails.logger.info("AWS SQS Poller before_request last_message_received_at: #{stats.last_message_received_at}")
      throw :stop_polling if end_polling
    end

    poller.poll do |msg|
      Rails.logger.info('Polls message')
      message_body = JSON.parse(msg[:body])
      job_name = message_body['job_instance']['name']
      Rails.logger.info("AWS SQS Poller message_body: #{message_body}")
      next unless Rails.configuration.alma[:jobs].keys.include?(job_name)

      dump = AlmaDumpFactory.bib_dump(message_body)
      # running dump creation in the background prevents the queue
      # event from timing out and requeuing
      Import::Alma.perform_async(
        dump.id,
        message_body['job_instance']['id']
      )
    rescue AlmaDumpFactory::AlmaDuplicateEventError
      Rails.logger.error("Rescue from AlmaDuplicateEventError with alma_process_id: #{message_body['job_instance']['id']}")
    end
  end
end

class AlmaDumpFactory
  attr_reader :message

  class AlmaDumpError < StandardError
    attr_reader :alma_message

    def initialize(alma_message)
      super
      @alma_message = alma_message
    end

    def message
      status = alma_message['job_instance']['status']['value']
      "Alma job completed with invalid status. Alma status: #{status}. Job id: #{alma_message['id']}"
    end
  end

  class AlmaDuplicateEventError < StandardError
  end

  def initialize(message)
    @message = message
  end

  def self.bib_dump(message)
    new(message).bib_dump
  end

  def bib_dump
    Dump.create(dump_type:,
                event: dump_event,
                generated_date: dump_event.start)
  end

  def dump_type
    @dump_type ||= Rails.configuration.alma[:jobs][job_name]['dump_type']
  end

  def job_name
    message['job_instance']['name']
  end

  def alma_job_status
    status = message['job_instance']['status']['value']
    raise AlmaDumpError, message unless status == 'COMPLETED_SUCCESS'

    status
  rescue StandardError => e
    Rails.logger.error(e.message)
    Honeybadger.notify(e)
    status
  end

  def dump_event
    @event ||= Event.create!(
      start: event_start,
      finish: event_finish,
      success: true,
      alma_job_status:,
      message_body: message.to_json
    )
  rescue ActiveRecord::RecordInvalid => e
    Rails.logger.error("#{e.message} message_body: #{message.to_json}")
    raise AlmaDuplicateEventError
  end

  def event_start
    message['job_instance']['start_time']
  end

  def event_finish
    message['job_instance']['end_time']
  end
end

1	# This service is intended to be run by a daemon. It watches the AWS SQS poll
2	# for full dump events and kicks off a job to process them.
3	class AwsSqsPoller	1✔
4	def self.poll	1✔
5	queue_url = Rails.configuration.alma['sqs_queue_url']	×
6	poller = Aws::SQS::QueuePoller.new(queue_url)	×
7	end_polling = false	×
8
9	# End polling if the process is killed by restarting.
10	Signal.trap('TERM') do	×
11	end_polling = true	×
12	end
13
14	poller.after_empty_receive do \|stats\|	×
15	Rails.logger.info("AWS SQS Poller after_empty_receive request_count: #{stats.request_count}")	×
16	Rails.logger.info("AWS SQS Poller after_empty_receive received_message_count: #{stats.received_message_count}")	×
17	Rails.logger.info("AWS SQS Poller after_empty_receive last_message_received_at: #{stats.last_message_received_at}")	×
18	end
19
20	poller.before_request do \|stats\|	×
21	Rails.logger.info("AWS SQS Poller before_request request_count: #{stats.request_count}")	×
22	Rails.logger.info("AWS SQS Poller before_request message_count: #{stats.received_message_count}")	×
23	Rails.logger.info("AWS SQS Poller before_request last_message_received_at: #{stats.last_message_received_at}")	×
24	throw :stop_polling if end_polling	×
25	end
26
27	poller.poll do \|msg\|	×
28	Rails.logger.info('Polls message')	×
29	message_body = JSON.parse(msg[:body])	×
30	job_name = message_body['job_instance']['name']	×
31	Rails.logger.info("AWS SQS Poller message_body: #{message_body}")	×
32	next unless Rails.configuration.alma[:jobs].keys.include?(job_name)	×
33
34	dump = AlmaDumpFactory.bib_dump(message_body)	×
35	# running dump creation in the background prevents the queue
36	# event from timing out and requeuing
37	Import::Alma.perform_async(	×
38	dump.id,
39	message_body['job_instance']['id']
40	)
41	rescue AlmaDumpFactory::AlmaDuplicateEventError
42	Rails.logger.error("Rescue from AlmaDuplicateEventError with alma_process_id: #{message_body['job_instance']['id']}")	×
43	end
44	end
45	end
46
47	class AlmaDumpFactory	1✔
48	attr_reader :message	1✔
49
50	class AlmaDumpError < StandardError	1✔
51	attr_reader :alma_message	1✔
52
53	def initialize(alma_message)	1✔
54	super	×
55	@alma_message = alma_message	×
56	end
57
58	def message	1✔
59	status = alma_message['job_instance']['status']['value']	×
60	"Alma job completed with invalid status. Alma status: #{status}. Job id: #{alma_message['id']}"	×
61	end
62	end
63
64	class AlmaDuplicateEventError < StandardError	1✔
65	end
66
67	def initialize(message)	1✔
68	@message = message	×
69	end
70
71	def self.bib_dump(message)	1✔
72	new(message).bib_dump	×
73	end
74
75	def bib_dump	1✔
76	Dump.create(dump_type:,	×
77	event: dump_event,
78	generated_date: dump_event.start)
79	end
80
81	def dump_type	1✔
82	@dump_type \|\|= Rails.configuration.alma[:jobs][job_name]['dump_type']	×
83	end
84
85	def job_name	1✔
86	message['job_instance']['name']	×
87	end
88
89	def alma_job_status	1✔
90	status = message['job_instance']['status']['value']	×
91	raise AlmaDumpError, message unless status == 'COMPLETED_SUCCESS'	×
92
93	status	×
94	rescue StandardError => e
95	Rails.logger.error(e.message)	×
96	Honeybadger.notify(e)	×
97	status	×
98	end
99
100	def dump_event	1✔
101	@event \|\|= Event.create!(	×
102	start: event_start,
103	finish: event_finish,
104	success: true,
105	alma_job_status:,
106	message_body: message.to_json
107	)
108	rescue ActiveRecord::RecordInvalid => e
109	Rails.logger.error("#{e.message} message_body: #{message.to_json}")	×
110	raise AlmaDuplicateEventError	×
111	end
112
113	def event_start	1✔
114	message['job_instance']['start_time']	×
115	end
116
117	def event_finish	1✔
118	message['job_instance']['end_time']	×
119	end
120	end

pulibrary / bibdata / b3c4a532-5da0-46f8-9c20-20018605a028

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous