Getting 0 duration on live transcriptions

[aaditya25052002]

Hey guys, given my logs could you please check if why am I getting the 0 duration on the transcriptions?

{"type"=>"Metadata", "transaction_key"=>"deprecated", "request_id"=>"86a0ee35-e61d-4c83-b654-c046a960377f", "sha256"=>"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "created"=>"2024-10-30T07:30:14.098Z", "duration"=>0.0, "channels"=>0}

[deepgram-community[bot]]

Hey there! It looks like you haven't connected your GitHub account to your Deepgram account. You can do this at https://community.deepgram.com - being verified through this process will allow our team to help you in a much more streamlined fashion.

[deepgram-community[bot]]

It looks like we're missing some important information to help debug your issue. Would you mind providing us with the following details in a reply?

• The programming language you are working in (e.g. JavaScript, Python).

[aaditya25052002]

I am working with ruby on rails, below is the given code:

require 'websocket-client-simple'
require 'base64'

module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
      @ws = WebSocket::Client::Simple.connect(
        "wss://api.deepgram.com/v1/listen?" +
          "punctuate=true&" +
          "channels=2&" +
          "sample_rate=8000&" +
          "encoding=mulaw" +
          "multichannel=true",
        headers: {
          "Authorization" => "Token #{ENV['DEEPGRAM_API_KEY']}"
        }
      )
      @inbuffer = ''.b
      @outbuffer = ''.b
      @inbound_chunks_started = false
      @outbound_chunks_started = false
      @latest_inbound_timestamp = 0
      @latest_outbound_timestamp = 0
      puts "Connected to Deepgram #{@ws}"
    end

    def subscribed
      stream_from "twilio_#{params[:call_sid]}"
    end

    def receive(data)
      chunk = JSON.parse(data)
      Rails.logger.debug "Received chunk: #{chunk}"
      Rails.logger.debug "Event: #{chunk['event']}"
      if chunk["event"] == "start"
        call_sid = chunk["start"]["callSid"]
        Rails.logger.debug call_sid
        # ActionCable.server.broadcast("call_#{call_sid}", call_sid: call_sid)
      elsif chunk["event"] == "media"
        media = chunk["media"]
        transcribe_stream(media)
        prepare_audio(media)
      elsif chunk["event"] == "stop"
        ActionCable.server.broadcast("call_#{params[:call_sid]}", event: "stop")
      end
    end

    private
      def find_verified_user
        verified_user = "test_user"
        verified_user
      end

      def transcribe_stream(base64_audio)
        @ws.on :open do
        end

        @ws.on :message do |msg|
          begin
            if msg.type == :text
              result = JSON.parse(msg.data)
              Rails.logger.debug result

              if result['is_final']
                transcript = result.dig('channel', 'alternatives', 0, 'transcript')
                if transcript && !transcript.empty?
                  puts "Transcript: #{transcript}"
                  # broadcast to channels from here
                end
              end
            end
          rescue JSON::ParserError => e
            puts "Error parsing message: #{e.message}"
          end
        end

        @ws.on :error do |e|
          Rails.logger.error "WebSocket Error: #{e.message}"
        end

        @ws.on :close do |e|
          Rails.logger.debug "WebSocket closed"
        end
      end

    def prepare_audio(media)
      return unless @ws.open?
      chunk_size = 160
      puts "Buffer before processing: #{@inbuffer}"
  
      chunk = Base64.decode64(media['payload'])
  
      if media['track'] == 'inbound'
        if @inbound_chunks_started && (@latest_inbound_timestamp + 20 < media['timestamp'].to_i)
          bytes_to_fill = 8 * (media['timestamp'].to_i - (@latest_inbound_timestamp + 20))
          @inbuffer << "\xFF" * bytes_to_fill
        else
          @inbound_chunks_started = true
        end
        @latest_inbound_timestamp = media['timestamp'].to_i
        @inbuffer << chunk
      end
  
      if media['track'] == 'outbound'
        if @outbound_chunks_started && (@latest_outbound_timestamp + 20 < media['timestamp'].to_i)
          bytes_to_fill = 8 * (media['timestamp'].to_i - (@latest_outbound_timestamp + 20))
          @outbuffer << "\xFF" * bytes_to_fill
        else
          @outbound_chunks_started = true
        end
        @latest_outbound_timestamp = media['timestamp'].to_i
        @outbuffer << chunk
      end
  
      puts "Inbound buffer size: #{@inbuffer.bytesize}"
      puts "Outbound buffer size: #{@outbuffer.bytesize}"
  
      if @inbuffer.bytesize >= chunk_size || @outbuffer.bytesize >= chunk_size
        combined_audio = @inbuffer.slice!(0, chunk_size)
        @ws.send(combined_audio)
      else
        Rails.logger.debug "Not enough data to send"
      end
    end
  end
end