Custom Rails Logger to Use Azure Application Insights

class Logger
  # Logging severity.
  #
  # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
  #
  module Severity
    # Low-level information, mostly for developers.
    DEBUG = 0
    # Generic (useful) information about system operation.
    INFO = 1
    # A warning.
    WARN = 2
    # A handleable error condition.
    ERROR = 3
    # An unhandleable error that results in a program crash.
    FATAL = 4
    # An unknown message that should always be logged.
    UNKNOWN = 5
  end
end

class Logger
  class LogDevice
   close()
   reopen(log = nil)
   write(message)
  end
end

$ gem install application_insights

$ bundle install

require 'application_insights'
tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
tc.track_trace 'My trace statement', ApplicationInsights::Channel::Contracts::SeverityLevel::INFORMATION, :properties => { 'custom property' => 'some value' }
tc.flush

require 'application_insights'

# setup unhandled exception handler
ApplicationInsights::UnhandledException.collect('<YOUR INSTRUMENTATION KEY GOES HERE>')

# raise an exception and this would be send to Application Insights Service
raise Exception, 'Oops!'

# set up the TrackRequest middleware in the rackup (config.ru) file
require_relative 'config/environment'
require 'application_insights'

key = ENV['APPINSIGHTS_INSTRUMENTATIONKEY']
if key != nil
  use ApplicationInsights::Rack::TrackRequest, key
end

run Rails.application

# For rails, suggest to set up this middleware in application.rb
# so that unhandled exceptions from controllers are also collected
# buffer size: 8096
key = ENV['APPINSIGHTS_INSTRUMENTATIONKEY']
if key != nil
  bufSize = 8096
  config.middleware.use ApplicationInsights::Rack::TrackRequest, key, bufSize
end

require 'application_insights'
sender = ApplicationInsights::Channel::AsynchronousSender.new
queue = ApplicationInsights::Channel::AsynchronousQueue.new sender
channel = ApplicationInsights::Channel::TelemetryChannel.new nil, queue
tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>', channel

# flush telemetry if we have 10 or more telemetry items in our queue
tc.channel.queue.max_queue_length = 10

# send telemetry to the service in batches of 5
tc.channel.sender.send_buffer_size = 5

# the background worker thread will be active for 5 seconds before it shuts down. if
# during this time items are picked up from the queue, the timer is reset.
tc.channel.sender.send_time = 5

# the background worker thread will poll the queue every 0.5 seconds for new items
tc.channel.sender.send_interval = 0.5

#
# File: application_insights_helper.rb
#
require 'application_insights'

module ApplicationInsightsHelper

  LogMessage = Struct.new(:datetime, :severity, :message)

  class ApplicationInsightsLogDevice < Logger::LogDevice
    @tc = nil

    def initialize()
      print 'AppInsightsLogger.initialize'
      appInsightKey = ENV['APPINSIGHTS_INSTRUMENTATIONKEY']
      if appInsightKey != nil
        sender = ApplicationInsights::Channel::AsynchronousSender.new
        queue = ApplicationInsights::Channel::AsynchronousQueue.new sender
        channel = ApplicationInsights::Channel::TelemetryChannel.new nil, queue

        @tc = ApplicationInsights::TelemetryClient.new appInsightKey, channel

        # flush telemetry if we have 10 or more telemetry items in our queue
        @tc.channel.queue.max_queue_length = 10

        # send telemetry to the service in batches of 5
        @tc.channel.sender.send_buffer_size = 5

        # the background worker thread will be active for 5 seconds before it shuts down. if
        # during this time items are picked up from the queue, the timer is reset.
        @tc.channel.sender.send_time = 5

        # the background worker thread will poll the queue every 0.5 seconds for new items
        @tc.channel.sender.send_interval = 0.5
      end
    end

    def write(message)
      return if @tc == nil

      level = nil

      if message.severity == 'FATAL'
        level = ApplicationInsights::Channel::Contracts::SeverityLevel::CRITICAL
      elsif message.severity == 'ERROR'
        level = ApplicationInsights::Channel::Contracts::SeverityLevel::ERROR
      elsif message.severity == 'WARN'
        level = ApplicationInsights::Channel::Contracts::SeverityLevel::WARNING
      elsif message.severity == 'INFO'
        level = ApplicationInsights::Channel::Contracts::SeverityLevel::INFORMATION
      end

      # only send info and above log to app insights to reduce log size.
      return if level == nil

      @tc.track_trace "#{Process.pid} #{message.message}", level
      @tc.flush
    end

    def reopen()
      # Nothing to do here.
      self
    end

    def close()
      # Nothing to do here.
    end

    def formatter()
      proc do |severity, datetime, progname, msg|
        message = LogMessage.new
        message.datetime = datetime
        message.severity = severity
        message.message = msg
        message
      end
    end
  end

  def self.newApplicationInsightsLogger()
    logDevice = ApplicationInsightsLogDevice.new
    logger = Logger.new(logDevice)

    if logDevice.respond_to?(:formatter)
      logger.formatter = logDevice.formatter
    end

    logger
  end
end

require_relative 'path/to/app_insights_helper'

Rails.application.configure do
   ...
   ...

   logger = AppInsightsHelper::newApplicationInsightsLogger
   config.logger.extend(ActiveSupport::Logger.broadcast(logger))

   ...
   ...