flow_chat 0.6.1 → 0.8.0

data/lib/flow_chat/whatsapp/client.rb

@@ -7,8 +7,12 @@ require "securerandom"
 module FlowChat
   module Whatsapp
     class Client
+      include FlowChat::Instrumentation
+
       def initialize(config)
         @config = config
+        FlowChat.logger.info { "WhatsApp::Client: Initialized WhatsApp client for phone_number_id: #{@config.phone_number_id}" }
+        FlowChat.logger.debug { "WhatsApp::Client: API base URL: #{FlowChat::Config.whatsapp.api_base_url}" }
       end
 
       # Send a message to a WhatsApp number
@@ -16,8 +20,28 @@ module FlowChat
       # @param response [Array] FlowChat response array [type, content, options]
       # @return [Hash] API response or nil on error
       def send_message(to, response)
-        message_data = build_message_payload(response, to)
-        send_message_payload(message_data)
+        type, content, _ = response
+        FlowChat.logger.info { "WhatsApp::Client: Sending #{type} message to #{to}" }
+        FlowChat.logger.debug { "WhatsApp::Client: Message content: '#{content.to_s.truncate(100)}'" }
+
+        result = instrument(Events::MESSAGE_SENT, {
+          to: to,
+          message_type: type.to_s,
+          content_length: content.to_s.length,
+          platform: :whatsapp
+        }) do
+          message_data = build_message_payload(response, to)
+          send_message_payload(message_data)
+        end
+
+        if result
+          message_id = result.dig("messages", 0, "id")
+          FlowChat.logger.debug { "WhatsApp::Client: Message sent successfully to #{to}, message_id: #{message_id}" }
+        else
+          FlowChat.logger.error { "WhatsApp::Client: Failed to send message to #{to}" }
+        end
+
+        result
       end
 
       # Send a text message
@@ -25,6 +49,7 @@ module FlowChat
       # @param text [String] Message text
       # @return [Hash] API response or nil on error
       def send_text(to, text)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending text message to #{to}" }
         send_message(to, [:text, text, {}])
       end
 
@@ -34,6 +59,7 @@ module FlowChat
       # @param buttons [Array] Array of button hashes with :id and :title
       # @return [Hash] API response or nil on error
       def send_buttons(to, text, buttons)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending interactive buttons to #{to} with #{buttons.size} buttons" }
         send_message(to, [:interactive_buttons, text, {buttons: buttons}])
       end
 
@@ -44,6 +70,8 @@ module FlowChat
       # @param button_text [String] Button text (default: "Choose")
       # @return [Hash] API response or nil on error
       def send_list(to, text, sections, button_text = "Choose")
+        total_items = sections.sum { |section| section[:rows]&.size || 0 }
+        FlowChat.logger.debug { "WhatsApp::Client: Sending interactive list to #{to} with #{sections.size} sections, #{total_items} total items" }
         send_message(to, [:interactive_list, text, {sections: sections, button_text: button_text}])
       end
 
@@ -54,6 +82,7 @@ module FlowChat
       # @param language [String] Language code (default: "en_US")
       # @return [Hash] API response or nil on error
       def send_template(to, template_name, components = [], language = "en_US")
+        FlowChat.logger.debug { "WhatsApp::Client: Sending template '#{template_name}' to #{to} in #{language}" }
         send_message(to, [:template, "", {
           template_name: template_name,
           components: components,
@@ -68,6 +97,7 @@ module FlowChat
       # @param mime_type [String] Optional MIME type for URLs (e.g., 'image/jpeg')
       # @return [Hash] API response
       def send_image(to, image_url_or_id, caption = nil, mime_type = nil)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending image to #{to} - #{url?(image_url_or_id) ? "URL" : "Media ID"}" }
         send_media_message(to, :image, image_url_or_id, caption: caption, mime_type: mime_type)
       end
 
@@ -80,6 +110,7 @@ module FlowChat
       # @return [Hash] API response
       def send_document(to, document_url_or_id, caption = nil, filename = nil, mime_type = nil)
         filename ||= extract_filename_from_url(document_url_or_id) if url?(document_url_or_id)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending document to #{to} - filename: #{filename}" }
         send_media_message(to, :document, document_url_or_id, caption: caption, filename: filename, mime_type: mime_type)
       end
 
@@ -90,6 +121,7 @@ module FlowChat
       # @param mime_type [String] Optional MIME type for URLs (e.g., 'video/mp4')
       # @return [Hash] API response
       def send_video(to, video_url_or_id, caption = nil, mime_type = nil)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending video to #{to}" }
         send_media_message(to, :video, video_url_or_id, caption: caption, mime_type: mime_type)
       end
 
@@ -99,6 +131,7 @@ module FlowChat
       # @param mime_type [String] Optional MIME type for URLs (e.g., 'audio/mpeg')
       # @return [Hash] API response
       def send_audio(to, audio_url_or_id, mime_type = nil)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending audio to #{to}" }
         send_media_message(to, :audio, audio_url_or_id, mime_type: mime_type)
       end
 
@@ -108,6 +141,7 @@ module FlowChat
       # @param mime_type [String] Optional MIME type for URLs (e.g., 'image/webp')
       # @return [Hash] API response
       def send_sticker(to, sticker_url_or_id, mime_type = nil)
+        FlowChat.logger.debug { "WhatsApp::Client: Sending sticker to #{to}" }
         send_media_message(to, :sticker, sticker_url_or_id, mime_type: mime_type)
       end
 
@@ -118,17 +152,23 @@ module FlowChat
       # @return [String] Media ID
       # @raise [StandardError] If upload fails
       def upload_media(file_path_or_io, mime_type, filename = nil)
+        FlowChat.logger.info { "WhatsApp::Client: Uploading media file - type: #{mime_type}, filename: #{filename}" }
+
         raise ArgumentError, "mime_type is required" if mime_type.nil? || mime_type.empty?
 
+        file_size = nil
         if file_path_or_io.is_a?(String)
           # File path
           raise ArgumentError, "File not found: #{file_path_or_io}" unless File.exist?(file_path_or_io)
           filename ||= File.basename(file_path_or_io)
+          file_size = File.size(file_path_or_io)
+          FlowChat.logger.debug { "WhatsApp::Client: Uploading file from path: #{file_path_or_io} (#{file_size} bytes)" }
           file = File.open(file_path_or_io, "rb")
         else
           # IO object
           file = file_path_or_io
           filename ||= "upload"
+          FlowChat.logger.debug { "WhatsApp::Client: Uploading file from IO object" }
         end
 
         # Upload directly via HTTP
@@ -136,6 +176,8 @@ module FlowChat
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
 
+        FlowChat.logger.debug { "WhatsApp::Client: Uploading to #{uri}" }
+
         # Prepare multipart form data
         boundary = "----WebKitFormBoundary#{SecureRandom.hex(16)}"
 
@@ -165,15 +207,45 @@ module FlowChat
         request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
         request.body = body
 
-        response = http.request(request)
-
-        if response.is_a?(Net::HTTPSuccess)
-          data = JSON.parse(response.body)
-          data["id"] || raise(StandardError, "Failed to upload media: #{data}")
-        else
-          Rails.logger.error "WhatsApp Media Upload error: #{response.body}"
-          raise StandardError, "Media upload failed: #{response.body}"
+        result = instrument(Events::MEDIA_UPLOAD, {
+          filename: filename,
+          mime_type: mime_type,
+          size: file_size,
+          platform: :whatsapp
+        }) do
+          response = http.request(request)
+
+          if response.is_a?(Net::HTTPSuccess)
+            data = JSON.parse(response.body)
+            media_id = data["id"]
+            if media_id
+              FlowChat.logger.info { "WhatsApp::Client: Media upload successful - media_id: #{media_id}" }
+              {success: true, media_id: media_id}
+            else
+              FlowChat.logger.error { "WhatsApp::Client: Media upload failed - no media_id in response: #{data}" }
+              raise StandardError, "Failed to upload media: #{data}"
+            end
+          else
+            FlowChat.logger.error { "WhatsApp::Client: Media upload error - #{response.code}: #{response.body}" }
+            raise StandardError, "Media upload failed: #{response.body}"
+          end
         end
+
+        result[:media_id]
+      rescue => error
+        FlowChat.logger.error { "WhatsApp::Client: Media upload exception: #{error.class.name}: #{error.message}" }
+
+        # Instrument the error
+        instrument(Events::MEDIA_UPLOAD, {
+          filename: filename,
+          mime_type: mime_type,
+          size: file_size,
+          success: false,
+          error: error.message,
+          platform: :whatsapp
+        })
+
+        raise
       ensure
         file&.close if file_path_or_io.is_a?(String)
       end
@@ -394,6 +466,11 @@ module FlowChat
       # @param message_data [Hash] Message payload
       # @return [Hash] API response or nil on error
       def send_message_payload(message_data)
+        to = message_data[:to]
+        message_type = message_data[:type]
+
+        FlowChat.logger.debug { "WhatsApp::Client: Sending API request to #{to} - type: #{message_type}" }
+
         uri = URI("#{FlowChat::Config.whatsapp.api_base_url}/#{@config.phone_number_id}/messages")
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
@@ -403,14 +480,24 @@ module FlowChat
         request["Content-Type"] = "application/json"
         request.body = message_data.to_json
 
+        FlowChat.logger.debug { "WhatsApp::Client: Making HTTP request to WhatsApp API" }
         response = http.request(request)
 
         if response.is_a?(Net::HTTPSuccess)
-          JSON.parse(response.body)
+          result = JSON.parse(response.body)
+          FlowChat.logger.debug { "WhatsApp::Client: API request successful - response: #{result}" }
+          result
         else
-          Rails.logger.error "WhatsApp API error: #{response.body}"
+          FlowChat.logger.error { "WhatsApp::Client: API request failed - #{response.code}: #{response.body}" }
           nil
         end
+      rescue Net::OpenTimeout, Net::ReadTimeout => network_error
+        # Let network timeouts bubble up for proper error handling
+        FlowChat.logger.error { "WhatsApp::Client: Network timeout: #{network_error.class.name}: #{network_error.message}" }
+        raise network_error
+      rescue => error
+        FlowChat.logger.error { "WhatsApp::Client: API request exception: #{error.class.name}: #{error.message}" }
+        nil
       end
 
       def send_media_message(to, media_type, url_or_id, caption: nil, filename: nil, mime_type: nil)

data/lib/flow_chat/whatsapp/configuration.rb

@@ -18,14 +18,19 @@ module FlowChat
         @business_account_id = nil
         @skip_signature_validation = false
 
+        FlowChat.logger.debug { "WhatsApp::Configuration: Initialized configuration with name: #{name || "anonymous"}" }
+
         register_as(name) if name.present?
       end
 
       # Load configuration from Rails credentials or environment variables
       def self.from_credentials
+        FlowChat.logger.info { "WhatsApp::Configuration: Loading configuration from credentials/environment" }
+
         config = new(nil)
 
         if defined?(Rails) && Rails.application.credentials.whatsapp
+          FlowChat.logger.debug { "WhatsApp::Configuration: Loading from Rails credentials" }
           credentials = Rails.application.credentials.whatsapp
           config.access_token = credentials[:access_token]
           config.phone_number_id = credentials[:phone_number_id]
@@ -35,6 +40,7 @@ module FlowChat
           config.business_account_id = credentials[:business_account_id]
           config.skip_signature_validation = credentials[:skip_signature_validation] || false
         else
+          FlowChat.logger.debug { "WhatsApp::Configuration: Loading from environment variables" }
           # Fallback to environment variables
           config.access_token = ENV["WHATSAPP_ACCESS_TOKEN"]
           config.phone_number_id = ENV["WHATSAPP_PHONE_NUMBER_ID"]
@@ -45,43 +51,68 @@ module FlowChat
           config.skip_signature_validation = ENV["WHATSAPP_SKIP_SIGNATURE_VALIDATION"] == "true"
         end
 
+        if config.valid?
+          FlowChat.logger.info { "WhatsApp::Configuration: Configuration loaded successfully - phone_number_id: #{config.phone_number_id}" }
+        else
+          FlowChat.logger.warn { "WhatsApp::Configuration: Incomplete configuration loaded - missing required fields" }
+        end
+
         config
       end
 
       # Register a named configuration
       def self.register(name, config)
+        FlowChat.logger.debug { "WhatsApp::Configuration: Registering configuration '#{name}'" }
         @@configurations[name.to_sym] = config
       end
 
       # Get a named configuration
       def self.get(name)
-        @@configurations[name.to_sym] || raise(ArgumentError, "WhatsApp configuration '#{name}' not found")
+        config = @@configurations[name.to_sym]
+        if config
+          FlowChat.logger.debug { "WhatsApp::Configuration: Retrieved configuration '#{name}'" }
+          config
+        else
+          FlowChat.logger.error { "WhatsApp::Configuration: Configuration '#{name}' not found" }
+          raise ArgumentError, "WhatsApp configuration '#{name}' not found"
+        end
       end
 
       # Check if a named configuration exists
       def self.exists?(name)
-        @@configurations.key?(name.to_sym)
+        exists = @@configurations.key?(name.to_sym)
+        FlowChat.logger.debug { "WhatsApp::Configuration: Configuration '#{name}' exists: #{exists}" }
+        exists
       end
 
       # Get all configuration names
       def self.configuration_names
-        @@configurations.keys
+        names = @@configurations.keys
+        FlowChat.logger.debug { "WhatsApp::Configuration: Available configurations: #{names}" }
+        names
       end
 
       # Clear all registered configurations (useful for testing)
       def self.clear_all!
+        FlowChat.logger.debug { "WhatsApp::Configuration: Clearing all registered configurations" }
         @@configurations.clear
       end
 
       # Register this configuration with a name
       def register_as(name)
+        FlowChat.logger.debug { "WhatsApp::Configuration: Registering configuration as '#{name}'" }
         @name = name.to_sym
         self.class.register(@name, self)
         self
       end
 
       def valid?
-        access_token && !access_token.to_s.empty? && phone_number_id && !phone_number_id.to_s.empty? && verify_token && !verify_token.to_s.empty?
+        is_valid = access_token && !access_token.to_s.empty? &&
+          phone_number_id && !phone_number_id.to_s.empty? &&
+          verify_token && !verify_token.to_s.empty?
+
+        FlowChat.logger.debug { "WhatsApp::Configuration: Configuration valid: #{is_valid}" }
+        is_valid
       end
 
       # API endpoints

data/lib/flow_chat/whatsapp/gateway/cloud_api.rb

@@ -10,26 +10,39 @@ module FlowChat
 
     module Gateway
       class CloudApi
+        include FlowChat::Instrumentation
+
+        attr_reader :context
+
         def initialize(app, config = nil)
           @app = app
           @config = config || FlowChat::Whatsapp::Configuration.from_credentials
           @client = FlowChat::Whatsapp::Client.new(@config)
+
+          FlowChat.logger.info { "CloudApi: Initialized WhatsApp Cloud API gateway with phone_number_id: #{@config.phone_number_id}" }
+          FlowChat.logger.debug { "CloudApi: Gateway configuration - API base URL: #{FlowChat::Config.whatsapp.api_base_url}" }
         end
 
         def call(context)
+          @context = context
           controller = context.controller
           request = controller.request
 
+          FlowChat.logger.debug { "CloudApi: Processing #{request.request_method} request to #{request.path}" }
+
           # Handle webhook verification
           if request.get? && request.params["hub.mode"] == "subscribe"
+            FlowChat.logger.info { "CloudApi: Handling webhook verification request" }
             return handle_verification(context)
           end
 
           # Handle webhook messages
           if request.post?
+            FlowChat.logger.info { "CloudApi: Handling webhook message" }
             return handle_webhook(context)
           end
 
+          FlowChat.logger.warn { "CloudApi: Invalid request method or parameters - returning bad request" }
           controller.head :bad_request
         end
 
@@ -41,11 +54,14 @@ module FlowChat
         def determine_message_handler(context)
           # Check if simulator mode was already detected and set in context
           if context["simulator_mode"]
+            FlowChat.logger.debug { "CloudApi: Using simulator message handler" }
             return :simulator
           end
 
           # Use global WhatsApp configuration
-          FlowChat::Config.whatsapp.message_handling_mode
+          mode = FlowChat::Config.whatsapp.message_handling_mode
+          FlowChat.logger.debug { "CloudApi: Using #{mode} message handling mode" }
+          mode
         end
 
         def handle_verification(context)
@@ -53,63 +69,108 @@ module FlowChat
           params = controller.request.params
 
           verify_token = @config.verify_token
+          provided_token = params["hub.verify_token"]
+          challenge = params["hub.challenge"]
 
-          if params["hub.verify_token"] == verify_token
-            controller.render plain: params["hub.challenge"]
+          FlowChat.logger.debug { "CloudApi: Webhook verification - provided token matches: #{provided_token == verify_token}" }
+
+          if provided_token == verify_token
+            # Use instrumentation for webhook verification success
+            instrument(Events::WEBHOOK_VERIFIED, {
+              challenge: challenge,
+              platform: :whatsapp
+            })
+
+            controller.render plain: challenge
           else
+            # Use instrumentation for webhook verification failure
+            instrument(Events::WEBHOOK_FAILED, {
+              reason: "Invalid verify token",
+              platform: :whatsapp
+            })
+
             controller.head :forbidden
           end
         end
 
         def handle_webhook(context)
           controller = context.controller
-          
+
           # Parse body
           begin
             parse_request_body(controller.request)
+            FlowChat.logger.debug { "CloudApi: Successfully parsed webhook request body" }
           rescue JSON::ParserError => e
-            Rails.logger.warn "Failed to parse webhook body: #{e.message}"
+            FlowChat.logger.error { "CloudApi: Failed to parse webhook body: #{e.message}" }
             return controller.head :bad_request
           end
-          
+
           # Check for simulator mode parameter in request (before validation)
           # But only enable if valid simulator token is provided
           is_simulator_mode = simulate?(context)
           if is_simulator_mode
+            FlowChat.logger.info { "CloudApi: Simulator mode enabled for this request" }
             context["simulator_mode"] = true
           end
 
           # Validate webhook signature for security (skip for simulator mode)
           unless is_simulator_mode || valid_webhook_signature?(controller.request)
-            Rails.logger.warn "Invalid webhook signature received"
+            FlowChat.logger.warn { "CloudApi: Invalid webhook signature received - rejecting request" }
             return controller.head :unauthorized
           end
 
+          FlowChat.logger.debug { "CloudApi: Webhook signature validation passed" }
+
           # Extract message data from WhatsApp webhook
           entry = @body.dig("entry", 0)
-          return controller.head :ok unless entry
+          unless entry
+            FlowChat.logger.debug { "CloudApi: No entry found in webhook body - returning OK" }
+            return controller.head :ok
+          end
 
           changes = entry.dig("changes", 0)
-          return controller.head :ok unless changes
+          unless changes
+            FlowChat.logger.debug { "CloudApi: No changes found in webhook entry - returning OK" }
+            return controller.head :ok
+          end
 
           value = changes["value"]
-          return controller.head :ok unless value
+          unless value
+            FlowChat.logger.debug { "CloudApi: No value found in webhook changes - returning OK" }
+            return controller.head :ok
+          end
 
           # Handle incoming messages
           if value["messages"]&.any?
             message = value["messages"].first
             contact = value["contacts"]&.first
 
-            context["request.id"] = message["from"]
+            phone_number = message["from"]
+            message_id = message["id"]
+            contact_name = contact&.dig("profile", "name")
+
+            # Use instrumentation for message received
+            instrument(Events::MESSAGE_RECEIVED, {
+              from: phone_number,
+              message: context.input,
+              message_type: message["type"],
+              message_id: message_id,
+              platform: :whatsapp
+            })
+
+            context["request.id"] = phone_number
             context["request.gateway"] = :whatsapp_cloud_api
-            context["request.message_id"] = message["id"]
-            context["request.msisdn"] = Phonelib.parse(message["from"]).e164
-            context["request.contact_name"] = contact&.dig("profile", "name")
+            context["request.platform"] = :whatsapp
+            context["request.message_id"] = message_id
+            context["request.msisdn"] = Phonelib.parse(phone_number).e164
+            context["request.contact_name"] = contact_name
             context["request.timestamp"] = message["timestamp"]
 
             # Extract message content based on type
             extract_message_content(message, context)
 
+            FlowChat.logger.debug { "CloudApi: Message content extracted - Type: #{message["type"]}, Input: '#{context.input}'" }
+
             # Determine message handling mode
             handler_mode = determine_message_handler(context)
 
@@ -127,7 +188,9 @@ module FlowChat
 
           # Handle message status updates
           if value["statuses"]&.any?
-            Rails.logger.info "WhatsApp status update: #{value["statuses"]}"
+            statuses = value["statuses"]
+            FlowChat.logger.info { "CloudApi: Received #{statuses.size} status update(s)" }
+            FlowChat.logger.debug { "CloudApi: Status updates: #{statuses.inspect}" }
           end
 
           controller.head :ok
@@ -137,18 +200,23 @@ module FlowChat
         def valid_webhook_signature?(request)
           # Check if signature validation is explicitly disabled
           if @config.skip_signature_validation
+            FlowChat.logger.debug { "CloudApi: Webhook signature validation is disabled" }
             return true
           end
 
           # Require app_secret for signature validation
           unless @config.app_secret && !@config.app_secret.empty?
-            raise FlowChat::Whatsapp::ConfigurationError, 
-              "WhatsApp app_secret is required for webhook signature validation. " \
-              "Either configure app_secret or set skip_signature_validation=true to explicitly disable validation."
+            error_msg = "WhatsApp app_secret is required for webhook signature validation. " \
+                       "Either configure app_secret or set skip_signature_validation=true to explicitly disable validation."
+            FlowChat.logger.error { "CloudApi: #{error_msg}" }
+            raise FlowChat::Whatsapp::ConfigurationError, error_msg
           end
 
           signature_header = request.headers["X-Hub-Signature-256"]
-          return false unless signature_header
+          unless signature_header
+            FlowChat.logger.warn { "CloudApi: No X-Hub-Signature-256 header found in request" }
+            return false
+          end
 
           # Extract signature from header (format: "sha256=<signature>")
           expected_signature = signature_header.sub("sha256=", "")
@@ -166,11 +234,19 @@ module FlowChat
           )
 
           # Compare signatures using secure comparison to prevent timing attacks
-          secure_compare(expected_signature, calculated_signature)
+          signature_valid = secure_compare(expected_signature, calculated_signature)
+
+          if signature_valid
+            FlowChat.logger.debug { "CloudApi: Webhook signature validation successful" }
+          else
+            FlowChat.logger.warn { "CloudApi: Webhook signature validation failed - signatures do not match" }
+          end
+
+          signature_valid
         rescue FlowChat::Whatsapp::ConfigurationError
           raise
         rescue => e
-          Rails.logger.error "Error validating webhook signature: #{e.message}"
+          FlowChat.logger.error { "CloudApi: Error validating webhook signature: #{e.class.name}: #{e.message}" }
           false
         end
 
@@ -185,24 +261,35 @@ module FlowChat
         end
 
         def extract_message_content(message, context)
-          case message["type"]
+          message_type = message["type"]
+          FlowChat.logger.debug { "CloudApi: Extracting content from #{message_type} message" }
+
+          case message_type
           when "text"
-            context.input = message.dig("text", "body")
+            content = message.dig("text", "body")
+            context.input = content
+            FlowChat.logger.debug { "CloudApi: Text message content: '#{content}'" }
           when "interactive"
             # Handle button/list replies
             if message.dig("interactive", "type") == "button_reply"
-              context.input = message.dig("interactive", "button_reply", "id")
+              content = message.dig("interactive", "button_reply", "id")
+              context.input = content
+              FlowChat.logger.debug { "CloudApi: Button reply ID: '#{content}'" }
             elsif message.dig("interactive", "type") == "list_reply"
-              context.input = message.dig("interactive", "list_reply", "id")
+              content = message.dig("interactive", "list_reply", "id")
+              context.input = content
+              FlowChat.logger.debug { "CloudApi: List reply ID: '#{content}'" }
             end
           when "location"
-            context["request.location"] = {
+            location = {
               latitude: message.dig("location", "latitude"),
               longitude: message.dig("location", "longitude"),
               name: message.dig("location", "name"),
               address: message.dig("location", "address")
             }
+            context["request.location"] = location
             context.input = "$location$"
+            FlowChat.logger.debug { "CloudApi: Location received - Lat: #{location[:latitude]}, Lng: #{location[:longitude]}" }
           when "image", "document", "audio", "video"
             context["request.media"] = {
               type: message["type"],
@@ -231,7 +318,7 @@ module FlowChat
           if response
             _type, prompt, choices, media = response
             rendered_message = render_response(prompt, choices, media)
-            
+
             # Queue only the response delivery asynchronously
             send_data = {
               msisdn: context["request.msisdn"],
@@ -261,7 +348,7 @@ module FlowChat
           if response
             _type, prompt, choices, media = response
             rendered_message = render_response(prompt, choices, media)
-            
+
             # For simulator mode, return the response data in the HTTP response
             # instead of actually sending via WhatsApp API
             message_payload = @client.build_message_payload(rendered_message, context["request.msisdn"])
@@ -285,7 +372,7 @@ module FlowChat
         def simulate?(context)
           # Check if simulator mode is enabled for this processor
           return false unless context["enable_simulator"]
-          
+
           # Then check if simulator mode is requested and valid
           @body.dig("simulator_mode") && valid_simulator_cookie?(context)
         end
@@ -293,27 +380,27 @@ module FlowChat
         def valid_simulator_cookie?(context)
           simulator_secret = FlowChat::Config.simulator_secret
           return false unless simulator_secret && !simulator_secret.empty?
-          
+
           # Check for simulator cookie
           request = context.controller.request
           simulator_cookie = request.cookies["flowchat_simulator"]
           return false unless simulator_cookie
-          
+
           # Verify the cookie is a valid HMAC signature
           # Cookie format: "timestamp:signature" where signature = HMAC(simulator_secret, "simulator:timestamp")
           begin
             timestamp_str, signature = simulator_cookie.split(":", 2)
             return false unless timestamp_str && signature
-            
+
             # Check timestamp is recent (within 24 hours for reasonable session duration)
             timestamp = timestamp_str.to_i
             return false if timestamp <= 0
             return false if (Time.now.to_i - timestamp).abs > 86400 # 24 hours
-            
+
             # Calculate expected signature
             message = "simulator:#{timestamp_str}"
             expected_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), simulator_secret, message)
-            
+
             # Use secure comparison
             secure_compare(signature, expected_signature)
           rescue => e