azure_application_insights 0.5.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d28bc24aac17bb3bd88e8080ec6abe6fa69faaebcda0dbb3d5f4746805f8dc6e
+  data.tar.gz: 06c89fcc256eef5c841b1cb214c7dff79f735213524fcc00b8b3c0a09c459e0d
+SHA512:
+  metadata.gz: 07312cd55bc77c5ca5b37db7d50a93e11a4876a3b156272b9ebe73104c236881c52509427a5f0caebe5f8c690041786abea5844c606a5aac4e38e9de49c93969
+  data.tar.gz: 582cb4bb087073c4b579c99cac093f64b9a96a2f0a305f9345460095495a36ececac8496b4c3a0755cafbfe582e1bbb0761ff69b2ef893e303d69b7255b36980

data/.github/workflows/gem-push.yml

@@ -0,0 +1,34 @@
+name: Ruby Gem
+
+on:
+  create:
+    branches: [ "master" ]
+    tags:        
+      - 'v*'
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    environment: production
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.gitignore

@@ -0,0 +1,40 @@
+*.gem
+*.rbc
+*.bundle
+mkmf.log
+/.config
+/coverage/
+/InstalledFiles
+/doc/
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Specific to RubyMine:
+/.idea/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - 2.3.3
+  - 2.4.0
+  - 2.5.0
+  - ruby-head
+
+cache: bundler
+
+before_install:
+  - gem install bundler
+
+matrix:
+  allow_failures:
+  - rvm: ruby-head
+
+install:
+  - bundle install

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+This file needs to be updated with every significant pull request. It is used to write down release notes.
+
+## Version 0.5.6
+* Expose request id to parent Rack application when using `ApplicationInsights::Rack::TrackRequest` middleware through `env['ApplicationInsights.request.id']`.
+* Implement operation context functionality for `ApplicationInsights::Rack::TrackRequest`.
+* Add functionality to accept a Request-Id header for telemetry correlation.
+* Add operation context to request tracking middleware.
+
+## Version 0.5.5
+* Add some basic logging when failed to send telemetry to the server
+* Add timestamp as an optional parameter to the TelemetryChannel::write() method
+
+## Version 0.5.4
+
+Changelog started after this release. 

data/CONTRIBUTING.md

@@ -0,0 +1,68 @@
+# How to Contribute
+
+If you're interested in contributing, take a look at the general [contributer's guide](https://github.com/Microsoft/ApplicationInsights-Home/blob/master/CONTRIBUTING.md) first.
+
+## Build Gem
+
+Run ```gem build application_insights.gemspec``` to generate the gem file.
+
+And you can install the gem to test it locally by running ```gem install application_insights-[version].gem```.
+
+## Run Test
+
+Make sure you have bundler installed, you can install it by ```sudo gem install bundler```. And run ```bundler install``` once to install all dependencies.
+
+Run ```rake test```.
+
+## Releasing new version
+
+This is for repository maintainers only:
+
+1. Create and merge develop->master PR https://github.com/Microsoft/ApplicationInsights-Ruby/compare/master...develop?expand=1
+2. Checkout latest `master`
+    ``` 
+    git checkout master
+    git pull
+    ```
+
+3. Remove old gem: `rm *.gem`
+4. [Build gem](https://github.com/Microsoft/ApplicationInsights-Ruby/blob/develop/CONTRIBUTING.md#build-gem) 
+5. Push gem: `gem push application_insights-0.5.5.gem`
+6. Check gem on [rubygems](https://rubygems.org/gems/application_insights)
+7. Tag code:
+    ```
+    git tag -a v0.5.5
+    git push origin v0.5.5
+    ```
+8. Update description of [release](https://github.com/Microsoft/ApplicationInsights-Ruby/releases/edit/v0.5.5) from [CHANGELOG.md](https://github.com/Microsoft/ApplicationInsights-Ruby/blob/master/CHANGELOG.md)
+9. Create a branch off `develop` branch
+    ```
+    git checkout develop
+    git pull
+    git checkout -b releaseUpdates
+    git push --set-upstream origin releaseUpdates
+    ```
+10. Update version in `/lib/application_insights/version.rb`
+11. Create new entry for the next release in `/CHANGELOG.md`
+12. Push changes
+    ```
+    git add -A
+    git commit -m "post release updates"
+    git push
+    ```
+13. Submit releaseUpdates->develop PR: https://github.com/Microsoft/ApplicationInsights-Ruby/compare/develop...releaseUpdates?expand=1
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require you to
+agree to a Contributor License Agreement (CLA) declaring that you have the right to,
+and actually do, grant us the rights to use your contribution. For details, visit
+https://cla.microsoft.com.
+
+When you submit a pull request, a CLA-bot will automatically determine whether you need
+to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the
+instructions provided by the bot. You will only need to do this once across all repositories using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in application_insights.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,11 @@
+AppInsights-Ruby
+Copyright (c) Microsoft Corporation
+All rights reserved. 
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,161 @@
+# Application Insights SDK for Ruby #
+
+[![Gem Version](https://badge.fury.io/rb/application_insights.svg)](http://badge.fury.io/rb/application_insights)
+[![Build Status](https://travis-ci.org/Microsoft/ApplicationInsights-Ruby.svg)](https://travis-ci.org/Microsoft/ApplicationInsights-Ruby)
+
+>Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
+> -- <cite>[Ruby - Official Site](https://www.ruby-lang.org/en/)</cite>
+
+This project extends the Application Insights API surface to support Ruby. [Application Insights](http://azure.microsoft.com/en-us/services/application-insights/) is a service that allows developers to keep their application available, performing and succeeding. This Ruby gem will allow you to send telemetry of various kinds (event, trace, exception, etc.) to the Application Insights service where they can be visualized in the Azure Portal.
+
+
+## Requirements ##
+
+Ruby 1.9.3 is currently supported by this gem.
+
+## Installation ##
+
+To install the latest release you can use *gem*.
+
+```
+$ gem install application_insights
+```
+
+## Usage ##
+
+Once installed, you can send telemetry to Application Insights. Here are a few samples.
+
+>**Note**: before you can send data to you will need an instrumentation key. Please see the [Getting an Application Insights Instrumentation Key](https://github.com/Microsoft/AppInsights-Home/wiki#getting-an-application-insights-instrumentation-key) section for more information.
+
+
+### Sending a simple event telemetry item ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc.track_event 'My event'
+tc.flush
+```
+
+### Sending an event telemetry item with custom properties and measurements ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc.track_event 'My event', :properties => { 'custom property' => 'some value' }, :measurements => { 'custom metric' => 13 }
+tc.flush
+```
+
+### Sending a trace telemetry item with custom properties ###
+```ruby
+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
+```
+
+### Sending a metric telemetry item (without and with optional values) ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc.track_metric 'My metric', 42
+# with all optional values set
+tc.track_metric 'My metric', 42, :kind => ApplicationInsights::Channel::Contracts::DataPointType::AGGREGATION, :count => 3, :min => 1, :max => 100, :std_dev => 10, :properties => { 'custom property' => 'some value' }
+tc.flush
+```
+
+### Sending an exception telemetry item with custom properties and measurements ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
+begin
+  raise ArgumentError, 'Something has gone wrong!'
+rescue => e
+  tc.track_exception e
+end
+tc.flush
+```
+
+### Configuring context for a telemetry client instance ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new '<YOUR INSTRUMENTATION KEY GOES HERE>'
+tc.context.application.ver = '1.2.3'
+tc.context.device.id = 'My current device'
+tc.context.device.oem_name = 'Asus'
+tc.context.device.model = 'X31A'
+tc.context.device.type = "Other"
+tc.context.user.id = 'santa@northpole.net'
+tc.track_trace 'My trace with context'
+tc.flush
+```
+
+### Configuring synchronous (default) channel properties ###
+```ruby
+require 'application_insights'
+tc = ApplicationInsights::TelemetryClient.new
+# 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
+```
+
+### Configuring an asynchronous channel instead of the synchronous default ###
+```ruby
+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
+# Note: the event will be sent on a separate thread; if the app finishes before
+#       the thread finishes, the data is lost
+tc.track_event 'My event'
+```
+
+### Configuring asynchronous channel properties ###
+```ruby
+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
+```
+
+### Collecting unhandled exceptions ###
+```ruby
+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, 'Boom!'
+```
+
+### Collecting requests for rack applications ###
+```ruby
+# set up the TrackRequest middleware in the rackup (config.ru) file
+require 'application_insights'
+use ApplicationInsights::Rack::TrackRequest, '<YOUR INSTRUMENTATION KEY GOES HERE>', <buffer size>
+# For rails, suggest to set up this middleware in application.rb so that unhandled exceptions from controllers are also collected
+config.middleware.use 'ApplicationInsights::Rack::TrackRequest', '<YOUR INSTRUMENTATION KEY GOES HERE>', <buffer size>
+```
+
+#### Rerieving the Request-Id value from ApplicationInsights ####
+```ruby
+# from time to time you may need to access a request's id from within your app
+application_insights_request_id = env['ApplicationInsights.request.id']
+
+# this can be used for a number of different purposes, including telemetry correlation
+uri = URI('http://api.example.com/search/?q=test')
+
+req = Net::HTTP::Get.new(uri)
+req['Request-Id'] = "#{application_insights_request_id}1" if application_insights_request_id
+
+Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
+```

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'yard'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/application_insights.rb']
+  test.verbose = true
+end
+
+YARD::Rake::YardocTask.new do |task|
+  task.files   = ['lib/**/*.rb', '-', 'LICENSE.txt', 'README.md']
+end
+
+task :default => [ :test, :build, :yard ]

data/application_insights.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'application_insights/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'azure_application_insights'
+  spec.version       = ApplicationInsights::VERSION
+  spec.authors       = ['Daniel Blasina']
+  spec.email         = ['blzk100@gmail.com']
+  spec.summary       = %q{Forked Application Insights SDK for Ruby}
+  spec.description   = %q{This project extends the Application Insights API surface to support Ruby.}
+  spec.homepage      = 'https://github.com/blasko03/ApplicationInsights-Ruby/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'yard', '~> 0.9.11'
+  spec.add_development_dependency 'redcarpet', '~> 3.2.2'
+  spec.add_development_dependency 'rack', '>= 1.0.0'
+  spec.add_development_dependency 'test-unit', '~> 3.0.8'
+  spec.add_development_dependency 'mocha', '~> 1.5.0'
+
+end

data/lib/application_insights/channel/asynchronous_queue.rb

@@ -0,0 +1,58 @@
+require_relative 'event'
+require_relative 'queue_base'
+
+module ApplicationInsights
+  module Channel
+    # An asynchronous queue for use in conjunction with the {AsynchronousSender}.
+    # The queue will notify the sender that it needs to pick up items when it
+    # reaches {#max_queue_length}, or when the consumer calls {#flush} via the
+    # {#flush_notification} event.
+    #
+    # @example
+    #   require 'application_insights'
+    #   require 'thread'
+    #   queue = ApplicationInsights::Channel::AsynchronousQueue.new nil
+    #   Thread.new do
+    #     sleep 1
+    #     queue.push 1
+    #     queue.flush
+    #   end
+    #   queue.flush_notification.wait
+    #   queue.flush_notification.clear
+    #   result = queue.pop
+    class AsynchronousQueue < QueueBase
+      # Initializes a new instance of the class.
+      # @param [SenderBase] sender the sender object that will be used in
+      #   conjunction with this queue. In addition to the sender object must
+      #   support a {AsynchronousSender#start} method which is invoked each time
+      #   an item is pushed to the queue as well as use the {#flush_notification}
+      #   event.
+      def initialize(sender)
+        @flush_notification = Event.new
+        super sender
+      end
+
+      # The flush notification {ApplicationInsights::Channel::Event} that the {#sender}
+      # will use to get notified that a flush is needed.
+      # @return [Event] object that the {#sender} can wait on.
+      attr_reader :flush_notification
+
+      # Adds the passed in item object to the queue and notifies the {#sender}
+      # to start an asynchronous send operation
+      # by calling {AsynchronousSender#start}.
+      # @param [Contracts::Envelope] item the telemetry envelope object to send
+      #   to the service.
+      def push(item)
+        super item
+        @sender.start if @sender
+      end
+
+      # Flushes the current queue by notifying the {#sender} via the
+      # {#flush_notification} event.
+      def flush
+        @flush_notification.set
+        @sender.start if @sender
+      end
+    end
+  end
+end

data/lib/application_insights/channel/asynchronous_sender.rb

@@ -0,0 +1,133 @@
+require_relative 'sender_base'
+require 'thread'
+
+module ApplicationInsights
+  module Channel
+    # An asynchronous sender that works in conjunction with the {AsynchronousQueue}.
+    # The sender object will start a worker thread that will pull items from the
+    # {#queue}. The thread will be created when the client calls {#start} and
+    # will check for queue items every {#send_interval} seconds. The worker thread
+    # can also be forced to check the queue by setting the
+    # {AsynchronousQueue#flush_notification} event.
+    #
+    # - If no items are found, the thread will go back to sleep.
+    # - If items are found, the worker thread will send items to the specified
+    #   service in batches of {#send_buffer_size}.
+    #
+    # If no queue items are found for {#send_time} seconds,  the worker thread
+    # will shut down (and {#start} will need  to be called again).
+    class AsynchronousSender < SenderBase
+      SERVICE_ENDPOINT_URI = 'https://dc.services.visualstudio.com/v2/track'
+      # Initializes a new instance of the class.
+      # @param [String] service_endpoint_uri the address of the service to send
+      #   telemetry data to.
+      def initialize(service_endpoint_uri = SERVICE_ENDPOINT_URI)
+        @send_interval = 1.0
+        @send_remaining_time = 0
+        @send_time = 3.0
+        @lock_work_thread = Mutex.new
+        @work_thread = nil
+        @start_notification_processed = true
+        super service_endpoint_uri
+      end
+
+      # The time span in seconds at which the the worker thread will check the
+      # {#queue} for items (defaults to: 1.0).
+      # @return [Fixnum] the interval in seconds.
+      attr_accessor :send_interval
+
+      # The time span in seconds for which the worker thread will stay alive if
+      # no items are found in the {#queue} (defaults to 3.0).
+      # @return [Fixnum] the interval in seconds.
+      attr_accessor :send_time
+
+      # The worker thread which checks queue items and send data every
+      # (#send_interval) seconds or upon flush.
+      # @return [Thread] the work thread
+      attr_reader :work_thread
+
+      # Calling this method will create a worker thread that checks the {#queue}
+      # every {#send_interval} seconds for a total duration of {#send_time}
+      # seconds for new items. If a worker thread has already been created,
+      # calling this method does nothing.
+      def start
+        @start_notification_processed = false
+        # Maintain one working thread at one time
+        unless @work_thread
+          @lock_work_thread.synchronize do
+            unless @work_thread
+              local_send_interval = [@send_interval, 0.1].max
+              @send_remaining_time = [@send_time, local_send_interval].max
+              @work_thread = Thread.new { run }
+              @work_thread.abort_on_exception = false
+            end
+          end
+        end
+      end
+
+      private
+
+      def run
+        # save the queue locally
+        local_queue = @queue
+        if local_queue.nil?
+          @work_thread = nil
+          return
+        end
+
+        begin
+          # fix up the send interval (can't be lower than 100ms)
+          local_send_interval = [@send_interval, 0.1].max
+
+          while true
+            @start_notification_processed = true
+            while true
+              # get at most @send_buffer_size items from the queue
+              data = []
+              @send_buffer_size.downto(1) do
+                item = local_queue.pop
+                break if not item
+                data.push item
+              end
+
+              # if we didn't get any items from the queue, we're done here
+              break if data.length == 0
+
+              # reset the send time
+              @send_remaining_time = @send_time
+
+              # finally send the data
+              send data
+            end
+
+            # wait at most @send_interval ms (or until we get signalled)
+            result = local_queue.flush_notification.wait local_send_interval
+            if result
+              local_queue.flush_notification.clear
+              next
+            end
+
+            # decrement the remaining time
+            @send_remaining_time -= local_send_interval
+            # If remaining time <=0 and there is no start notification unprocessed,
+            # then stop the working thread
+            if @send_remaining_time <= 0 && @start_notification_processed
+              # Note: there is still a chance some start notification could be
+              # missed, e.g., the start method got triggered between the above and
+              # following line. However the data is not lost as it would be
+              # processed later when next start notification comes after the worker
+              # thread stops. The cost to ensure no notification miss is high where
+              # a lock is required each time the start method calls.
+              @work_thread = nil
+              break
+            end
+          end
+        rescue Exception => e
+          # Make sure work_thread sets to nil when it terminates abnormally
+          @work_thread = nil
+          @logger.error('application_insights') { "Asynchronous sender work thread terminated abnormally: #{e.to_s}" }
+        end
+      end
+    end
+  end
+end

data/lib/application_insights/channel/contracts/application.rb

@@ -0,0 +1,14 @@
+require_relative 'json_serializable'
+
+module ApplicationInsights::Channel::Contracts
+  class Application
+    include JsonSerializable
+
+    attr_accessor :ver, :build
+
+    attribute_mapping(
+      ver: 'ai.application.ver',
+      build: 'ai.application.build'
+    )
+  end
+end

data/lib/application_insights/channel/contracts/cloud.rb

@@ -0,0 +1,14 @@
+require_relative 'json_serializable'
+
+module ApplicationInsights::Channel::Contracts
+  class Cloud
+    include JsonSerializable
+
+    attr_accessor :role_name, :role_instance
+
+    attribute_mapping(
+      role_name: 'ai.cloud.role',
+      role_instance: 'ai.cloud.roleInstance'
+    )
+  end
+end

data/lib/application_insights/channel/contracts/data.rb

@@ -0,0 +1,14 @@
+require_relative 'json_serializable'
+
+module ApplicationInsights::Channel::Contracts
+  class Data
+    include JsonSerializable
+
+    attr_accessor :base_type, :base_data
+
+    attribute_mapping(
+      base_type: 'baseType',
+      base_data: 'baseData'
+    )
+  end
+end