freddy 2.0.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ae99c2d347a67110923b71ffac1af46c706d177b39b82c3adaae4db3f686a1d
-  data.tar.gz: 557210126d3c4cdff8f0946ee5b6882e3334126c3cb0ae900df823f6e762fdd9
+  metadata.gz: 445e69f7be1822b3d6f8703086134081d944758ca5013c1d0e24331ec0d3e6b3
+  data.tar.gz: 9d918d1713c809253187727bd4adfa84584171abc07921e97429a8f8381a4ab6
 SHA512:
-  metadata.gz: a2ee88b1ec7e51523ae6b3851f07b398b9093d90b193712bce172a09764d2a683d0b5209ced2a4a524248d8ffab36074b8a0b65c662ef9844f319424ccb32e93
-  data.tar.gz: ea65f5f23e18c768098c1eec7edc299a146f0fc830a0a57b5e9d1f725b5fe6f0b442b017ecd08b80f6242424a6a0958b57c8514cdf015bca07e4d316e88edc56
+  metadata.gz: b76ebf99d84beea8fdb5e6557f780ab5ef0932cc177329e5524da4cf2a073ef8376e42f2c127614a60bd97566d3e460541d1c6a3e1a8ebe6f915e008b51e2577
+  data.tar.gz: 618367f3bb21b08a68d914c6f011b128764730a3555c7a46bd610703df13547b81aa4f09bc075058168b91fa5e9a72206de49ea6442d7c6cc1ae95ccf7901570

data/.github/workflows/ci.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.7']
+        ruby-version: ['2.6']
     services:
       rabbitmq:
         image: rabbitmq

data/.ruby-version

@@ -1 +1 @@
-2.7
+2.6

data/README.md

@@ -22,39 +22,60 @@ These message queues have been tested and are working with Freddy. Other queues
 ### Simple delivery
 
 #### Send and forget
+
 Sends a `message` to the given `destination`. If there is no consumer then the
 message stays in the queue until somebody consumes it.
+
 ```ruby
-  freddy.deliver(destination, message)
+freddy.deliver(destination, message)
 ```
 
 #### Expiring messages
+
 Sends a `message` to the given `destination`. If nobody consumes the message in
 `timeout` seconds then the message is discarded. This is useful for showing
 notifications that must happen in a certain timeframe but where we don't really
 care if it reached the destination or not.
+
 ```ruby
 freddy.deliver(destination, message, timeout: 5)
 ```
 
+#### Compressed messages
+
+Sends a `message` to the given `destination`. If `compress` is passed as an option parameter, it will compress the 
+payload according to the algorithm provided. Currently the `zlib` algorithm is implemented to compress the payload. 
+The message heading specify the `content-encoding` indicating the compression algorithm used. 
+
+```ruby
+freddy.deliver(destination, message, compress: 'zlib')
+```
+
 ### Request delivery
+
 #### Expiring messages
+
 Sends a `message` to the given `destination`. Has a default timeout of 3 and
 discards the message from the queue if a response hasn't been returned in that
 time.
+
 ```ruby
 response = freddy.deliver_with_response(destination, message)
 ```
 
 #### Persistant messages
+
 Sends a `message` to the given `destination`. Keeps the message in the queue if
 a timeout occurs.
+
 ```ruby
 response = freddy.deliver_with_response(destination, message, timeout: 4, delete_on_timeout: false)
 ```
 
 #### Errors
+
 `deliver_with_response` raises an error if an error is returned. This can be handled by rescuing from `Freddy::InvalidRequestError` and `Freddy::TimeoutError` as:
+
 ```ruby
 begin
   response = freddy.deliver_with_response 'Q', {}
@@ -66,6 +87,7 @@ rescue Freddy::TimeoutError => e
 ```
 
 ## Responding to messages
+
 ```ruby
 freddy.respond_to destination do |message, msg_handler|
   # ...
@@ -73,8 +95,9 @@ end
 ```
 
 The callback is called with 2 arguments
-  * the parsed message (note that in the message all keys are symbolized)
-  * the `MessageHandler` (described further down)
+
+* the parsed message (note that in the message all keys are symbolized)
+* the `MessageHandler` (described further down)
 
 ## The MessageHandler
 
@@ -82,17 +105,20 @@ When responding to messages the MessageHandler is given as the second argument.
 
 The following operations are supported:
 
-  * responding with a successful response
+* responding with a successful response
+
 ```ruby
 msg_handler.success(response = nil)
 ```
 
-  * responding with an error response
+* responding with an error response
+
 ```ruby
 msg_handler.error(error: "Couldn't process message")
 ```
 
 ## Tapping into messages
+
 When it's necessary to receive messages but not consume them, consider tapping.
 
 ```ruby
@@ -132,13 +158,15 @@ end
 ## The ResponderHandler
 
 When responding to a message or tapping the ResponderHandler is returned.
+
 ```ruby
 responder_handler = freddy.respond_to ....
 ```
 
 The following operations are supported:
 
-  * stop responding
+* stop responding
+
 ```ruby
 responder_handler.shutdown
 ```
@@ -155,11 +183,9 @@ This is not compatible with `opentelemetry-instrumentation-bunny` library.
 
 *freddy* uses a thread pool to run concurrent responders. The thread pool is unique for each *tap_into* and *respond_to* responder. Thread pool size can be configured by passing the configuration option *max_concurrency*. Its default value is 4. e.g. If your application has 2 *respond_to* responders and 1 *tap_into* responder with *max_concurrency* set to 3 then your application may process up to 9 messages in parallel.
 
-
 Note that while it is possible to use *deliver_with_response* inside a *respond_to* block,
 it is not possible to use another *respond_to* block inside a different *respond_to* block.
 
-
 Note also that other configuration options for freddy users
 such as pool sizes for DB connections need to match or exceed *max_concurrency*
 to avoid running out of resources.

data/freddy.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary       = 'API for inter-application messaging supporting acknowledgements and request-response'
   spec.license       = 'MIT'
   spec.homepage      = 'https://github.com/salemove/freddy'
-  spec.required_ruby_version = '>= 2.7'
+  spec.required_ruby_version = '>= 2.6'
 
   spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'opentelemetry-api', '~> 1.0.0.rc3'
   spec.add_dependency 'opentelemetry-semantic_conventions', '~> 1.0'
   spec.add_dependency 'thread', '~> 0.1'
+  spec.add_dependency 'zlib', '~> 1.1'
 end

data/lib/freddy/adapters/bunny_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'bunny'
+require 'forwardable'
 
 class Freddy
   module Adapters
@@ -67,7 +68,7 @@ class Freddy
 
         def subscribe(manual_ack: false)
           @queue.subscribe(manual_ack: manual_ack) do |info, properties, payload|
-            parsed_payload = Payload.parse(payload)
+            parsed_payload = Payload.parse(payload, properties[:content_encoding])
             delivery = Delivery.new(
               parsed_payload, properties, info.routing_key, info.delivery_tag, info.exchange
             )

data/lib/freddy/delivery.rb

@@ -25,7 +25,7 @@ class Freddy
     end
 
     def in_span(force_follows_from: false, &block)
-      name = "#{@exchange}.#{@routing_key} receive"
+      name = "#{@exchange}.#{@routing_key} process"
       kind = OpenTelemetry::Trace::SpanKind::CONSUMER
       producer_context = OpenTelemetry.propagation.extract(@metadata[:headers] || {})
 
@@ -35,12 +35,12 @@ class Freddy
         links = []
         links << OpenTelemetry::Trace::Link.new(producer_span_context) if producer_span_context.valid?
 
-        # In general we should start a new trace here and just link two traces
-        # together. But Zipkin (which we currently use) doesn't support links.
-        # So even though the root trace could finish before anything here
-        # starts executing, we'll continue with the root trace here as well.
-        OpenTelemetry::Context.with_current(producer_context) do
-          Freddy.tracer.in_span(name, attributes: span_attributes, links: links, kind: kind, &block)
+        root_span = Freddy.tracer.start_root_span(name, attributes: span_attributes, links: links, kind: kind)
+
+        OpenTelemetry::Trace.with_span(root_span) do
+          block.call
+        ensure
+          root_span.finish
         end
       else
         OpenTelemetry::Context.with_current(producer_context) do
@@ -60,7 +60,7 @@ class Freddy
         OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION => @exchange,
         OpenTelemetry::SemanticConventions::Trace::MESSAGING_DESTINATION_KIND => destination_kind,
         OpenTelemetry::SemanticConventions::Trace::MESSAGING_RABBITMQ_ROUTING_KEY => @routing_key,
-        OpenTelemetry::SemanticConventions::Trace::MESSAGING_OPERATION => 'receive'
+        OpenTelemetry::SemanticConventions::Trace::MESSAGING_OPERATION => 'process'
       }
 
       # There's no correlation_id when a message was sent using

data/lib/freddy/encoding.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+class Freddy
+  class Encoding
+    ZLIB_CONTENT_ENCODING = 'zlib'
+
+    def self.compress(data, encoding)
+      case encoding
+      when ZLIB_CONTENT_ENCODING
+        ::Zlib::Deflate.deflate(data)
+      else
+        data
+      end
+    end
+
+    def self.uncompress(data, encoding)
+      case encoding
+      when ZLIB_CONTENT_ENCODING
+        ::Zlib::Inflate.inflate(data)
+      else
+        data
+      end
+    end
+  end
+end

data/lib/freddy/payload.rb

@@ -4,9 +4,10 @@ require 'oj'
 
 class Freddy
   class Payload
-    def self.parse(payload)
+    def self.parse(payload, encoding)
       return {} if payload == 'null'
 
+      payload = Freddy::Encoding.uncompress(payload, encoding)
       json_handler.parse(payload)
     end
 

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -20,7 +20,10 @@ class Freddy
         )
         Tracing.inject_tracing_information_to_properties!(properties)
 
-        json_payload = Payload.dump(payload)
+        json_payload = Freddy::Encoding.compress(
+          Payload.dump(payload),
+          properties[:content_encoding]
+        )
 
         # Connection adapters handle thread safety for #publish themselves. No
         # need to lock these.

data/lib/freddy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Freddy
-  VERSION = '2.0.0'
+  VERSION = '2.2.2'
 end

data/lib/freddy.rb

@@ -65,7 +65,7 @@ class Freddy
   #   Received message as a ruby hash with symbolized keys
   # @yieldparam [#success, #error] handler
   #   Handler for responding to messages. Use handler#success for successful
-  #   respone and handler#error for error response.
+  #   response and handler#error for error response.
   #
   # @return [#shutdown]
   #
@@ -99,7 +99,7 @@ class Freddy
   # consuming them. It is useful for general messages that two or more clients
   # are interested.
   #
-  # @param [String] pattern
+  # @param [String] pattern_or_patterns
   #   the destination pattern. Use `#` wildcard for matching 0 or more words.
   #   Use `*` to match exactly one word.
   # @param [Hash] options
@@ -152,15 +152,18 @@ class Freddy
   # @option options [Integer] :timeout (0)
   #   discards the message after given seconds if nobody consumes it. Message
   #   won't be discarded if timeout it set to 0 (default).
-  #
+  # @option options [String] :compress (nil)
+  #   - 'zlib' - compresses the payload with zlib
   # @return [void]
   #
   # @example
   #   freddy.deliver 'Metrics', user_id: 5, metric: 'signed_in'
   def deliver(destination, payload, options = {})
     timeout = options.fetch(:timeout, 0)
+    compression_algorithm = options.fetch(:compress, nil)
     opts = {}
     opts[:expiration] = (timeout * 1000).to_i if timeout.positive?
+    opts[:content_encoding] = compression_algorithm if compression_algorithm
 
     @send_and_forget_producer.produce(destination, payload, opts)
   end

data/spec/freddy/freddy_spec.rb

@@ -49,6 +49,29 @@ describe Freddy do
         expect(processed_after_timeout).to be(true)
       end
     end
+
+    context 'with compress' do
+      it 'compresses the payload' do
+        expect(Freddy::Encoding).to receive(:compress).with(anything, 'zlib').and_call_original
+
+        freddy.tap_into(destination) { |msg| @tapped_message = msg }
+        freddy.deliver(destination, payload, compress: 'zlib')
+        default_sleep
+
+        wait_for { @tapped_message }
+        expect(@tapped_message).to eq(payload)
+      end
+    end
+
+    context 'without compress' do
+      it 'does not compress the payload' do
+        freddy.tap_into(destination) { |msg| @tapped_message = msg }
+        deliver
+
+        wait_for { @tapped_message }
+        expect(@tapped_message).to eq(payload)
+      end
+    end
   end
 
   context 'when making a synchronized request' do

data/spec/integration/tracing_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Tracing' do
-  let(:logger) { spy }
+  let(:exporter) { SPAN_EXPORTER }
+
+  before do
+    exporter.reset
+  end
 
   context 'when receiving a traced request' do
     let(:freddy) { Freddy.build(logger, config) }
@@ -106,11 +110,48 @@ describe 'Tracing' do
     end
   end
 
+  context 'when receiving a broadcast' do
+    let(:freddy) { Freddy.build(logger, config) }
+    let(:destination) { random_destination }
+
+    before do
+      freddy.tap_into(destination) do
+        @deliver_span = current_span_attributes
+      end
+    end
+
+    after do
+      freddy.close
+    end
+
+    it 'creates a new trace and links it with the sender' do
+      initiator_span = nil
+      Freddy.tracer.in_span('test') do
+        initiator_span = current_span_attributes
+        freddy.deliver(destination, {})
+      end
+      wait_for { @deliver_span }
+
+      expect(exporter.finished_spans.map(&:name))
+        .to match([
+                    /\.\w+ send/,
+                    'test',
+                    /freddy-topic\.\w+ process/
+                  ])
+
+      expect(@deliver_span.fetch(:trace_id)).not_to eq(initiator_span.fetch(:trace_id))
+
+      link = @deliver_span.fetch(:links)[0]
+      expect(link.span_context.trace_id).to eq(initiator_span.fetch(:trace_id))
+    end
+  end
+
   def current_span_attributes
     {
       trace_id: current_span.context.trace_id,
       parent_id: current_span.parent_span_id,
-      span_id: current_span.context.span_id
+      span_id: current_span.context.span_id,
+      links: current_span.links || []
     }
   end
 

data/spec/spec_helper.rb

@@ -11,6 +11,13 @@ require 'freddy'
 require 'logger'
 require 'hamster/experimental/mutable_set'
 
+SPAN_EXPORTER = OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
+span_processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(SPAN_EXPORTER)
+
+OpenTelemetry::SDK.configure do |c|
+  c.add_span_processor(span_processor)
+end
+
 Thread.abort_on_exception = true
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Glia TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2021-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: Messaging API
 email:
 - techmovers@salemove.com
@@ -134,6 +148,7 @@ files:
 - lib/freddy/consumers/response_consumer.rb
 - lib/freddy/consumers/tap_into_consumer.rb
 - lib/freddy/delivery.rb
+- lib/freddy/encoding.rb
 - lib/freddy/error_response.rb
 - lib/freddy/invalid_request_error.rb
 - lib/freddy/message_handler.rb
@@ -174,14 +189,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.9
 signing_key: 
 specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response