cloud_cost_tracker 0.1.0

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+.bundle
+Gemfile.lock
+config/accounts.yml
+config/database.yml
+config/policies
+pkg/*
+*~
+.DS_Store
+*.tmproj
+db/*.sqlite3
+log/*.log
+tmp/**/*
+doc
+doc/**/*
+.yardoc

data/.yardopts

@@ -0,0 +1 @@
+--no-private --protected lib/**/*.rb - LICENSE.TXT

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', 
+  :version => 2, 
+  :cli => "--color --format documentation -r ./spec/spec_helper.rb" do
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+    watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.TXT

@@ -0,0 +1,10 @@
+----------------
+*MIT License*
+
+Copyright (c) 2012 Benton Roberts
+
+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,123 @@
+Cloud Cost Tracker
+================
+Records expenses for cloud computing resources in an ActiveRecord database.
+
+  *BETA VERSION - supports EC2 servers, EBS volumes, S3 buckets, and RDS servers*
+
+
+----------------
+What is it?
+----------------
+The Cloud Cost Tracker periodically polls one or more cloud computing accounts and determines the state of their associated cloud computing "resources": compute instances, disk volumes, stored objects, and so on. Each time an account is polled, a set of ActiveRecord objects ({CloudCostTracker::Billing::BillingRecord}s) is created or updated for each resource, containing the cost for that resource over the period of the BillingRecord.
+
+The software can also attach "billing codes" to any resource, and to its corresponding billing records. These are arbitrary pairs of Strings which can be used to track resources for internal billing. By default, any AWS tags associated with a resource are translated into billing codes, but a framework is also provided for easily writing custom resource coding policies.
+
+
+----------------
+Why is it?
+----------------
+The Cloud Cost Tracker was created in response to the fact that Amazon Web Services does not provide per-resource billing information, which makes *internal* billing very difficult for organizations that make extensive use of AWS. Amazon's proposed solution -- creating, deleting, and cross-authorizing different AWS accounts for each internal billing entity -- is often not workable for organizations that need to perform these operations frequently. As a solution, this gem watches all resources across many accounts, and provides a way to define custom policies for assigning internal billing codes to all recorded expenses.
+
+The Cloud Cost Tracker is intended to be a foundation library, on top of which more complex cloud billing / accounting applications can be built. Custom billing policies for cloud services and resources that are not yet implemented are simple to create, and are discovered automatically. Here are some currently-included default policies:
+
+  * EC2 server instance runtime costs:
+    {CloudCostTracker::Billing::Compute::AWS::ServerBillingPolicy}
+  * EBS volume storage costs:
+    {CloudCostTracker::Billing::Compute::AWS::VolumeBillingPolicy}
+  * S3 bucket storage costs:
+    {CloudCostTracker::Billing::Storage::AWS::DirectoryBillingPolicy}
+  * RDS server runtime costs:
+    {CloudCostTracker::Billing::AWS::RDS::ServerBillingPolicy}
+  * RDS server storage costs:
+    {CloudCostTracker::Billing::AWS::RDS::ServerStorageBillingPolicy}
+
+
+----------------
+Installation
+----------------
+Install the Cloud Cost Tracker gem, or list it in your `Gemfile`.
+
+    gem install cloud_cost_tracker [mysql2]
+
+
+----------------
+Usage
+----------------
+1) Add the BillingRecords table into your database.
+   Put `require 'cloud_cost_tracker/tasks'` in your Rakefile, then run:
+
+    rake db:migrate:tracker
+
+2) In your Ruby app, `require` the gem, and set up an ActiveRecord connection.
+   In Rails, the connection is set up for you automatically on startup,
+   but here's an example for a non-Rails app:
+
+    require 'cloud_cost_tracker'
+    ActiveRecord::Base.establish_connection({
+      :adapter => 'mysql2', :database => 'cloud_cost_tracker',
+      :pool => 6    # reserve at least one connection per tracked account
+    })
+
+3) Track all accounts loaded from a YAML file.
+
+    tracker = CloudCostTracker::Tracker.new(
+      YAML::load(File.read 'accounts.yml'), :logger => Logger.new(STDOUT)
+    ).start
+
+  Here are the contents of the example file: `config/accounts.example.yml`:
+
+    AWS EC2 production account:   # The account name - can be anything
+      :provider: AWS      # This is the Fog provider Module
+      :service: Compute   # Fog service Module. So, EC2 = Fog::Compute::AWS
+      :credentials:
+        :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+        :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+      :delay: 120 # Wait time between successive pollings (in seconds)
+      :exclude_resources:
+      - :account  # No need to poll for accounts - those are listed here
+      - :flavors  # You may or may not want EC2 server types
+      - :images   # Takes a while to list all AMIs (works though)
+    AWS S3 development account:
+      :provider: AWS     # S3 = Fog::Storage::AWS
+      :service: Storage
+      :credentials:
+        :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+        :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+      :delay: 150
+      :exclude_resources:  # Pricing by Bucket is supported, but not by Object
+      - :files # This is required for S3 - objects can't be polled directly
+
+The tracker will run asynchronously, with one thread per account.
+Once the first account has been polled, and its resources coded,
+{CloudCostTracker::Billing::BillingRecord}s will be generated for
+each billable resource, and available through ActiveRecord.
+
+
+----------------
+Development
+----------------
+This project is still in its early stages, but most of the framework is in place.
+More resource costs need to be modeled as
+{CloudCostTracker::Billing::ResourceBillingPolicy} classes, but the patterns for
+doing so are now laid out. For the details, see {file:writing-billing-policies.md},
+{file:writing-coding-policies.md}, and the API documentation.
+
+Helping hands are appreciated!
+
+
+----------------
+*Getting started with development*
+
+1) Install project dependencies
+
+    gem install rake bundler
+
+2) Fetch the project code
+
+    git clone https://github.com/benton/cloud_cost_tracker.git
+    cd cloud_cost_tracker
+
+3) Bundle up and run the tests
+
+    bundle && rake
+

data/Rakefile

@@ -0,0 +1,15 @@
+# Set up bundler
+%w{rubygems bundler bundler/gem_tasks}.each {|dep| require dep}
+bundles = [:default]
+Bundler.setup(:default)
+require './lib/cloud_cost_tracker'
+case CloudCostTracker.env
+when 'development'  then Bundler.setup(:default, :development)
+when 'test'         then Bundler.setup(:default, :development, :test)
+end
+
+# Load all tasks from 'lib/tasks'
+Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each {|ext| load ext}
+
+desc 'Default: run specs.'
+task :default => :spec

data/billing issues.md

@@ -0,0 +1,4 @@
+* EBS snapshots do not report their size, only the volume_size they came from. This makes calculating their cost impossible unless it's the first snapshot from that volume.
+
+* EBS snapshots are stored in S3 and priced by region, but they do not report their region.
+

data/bin/cloud_cost_tracker

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#   Uses the Fog gem to generate billing records for cloud computing resources
+#
+# == Usage
+#   cloud_cost_tracker.rb [options] DB_CONFIG_FILE.YML ACCOUNTS_CONFIG_FILE.YML
+#
+# == Options (all options can be put into the config file)
+#   -d, --delay [INTEGER]       Seconds between status updates. default = 180
+#   -l, --log-level [LEVEL]     Sets Log4r level for console output. default = INFO
+#   -m, --migrate               Update database schema
+#   -h, --help                  Displays help message
+#
+# == Author
+#   Benton Roberts
+
+require 'optparse'
+require 'cloud_cost_tracker'
+LOG_LVLS = {
+  "DEBUG" => ::Logger::DEBUG,
+  "INFO"  => ::Logger::INFO,
+  "WARN"  => ::Logger::WARN,
+  "ERROR" => ::Logger::ERROR,
+  "FATAL" => ::Logger::FATAL
+}
+
+module CloudCostTracker
+  class CloudCostTrackerConsoleApp
+
+    def initialize
+      @log = FogTracker.default_logger(STDOUT)
+      parse_options
+      @log.info "Loading database configuration from #{ARGV[0]}"
+      config = YAML::load(File.open(ARGV[0]))[CloudCostTracker.env]
+      puts "Using database #{config['database']}..."
+      ActiveRecord::Base.establish_connection(config)
+      migrate if @opts[:migrate]
+      @log.info "Loading account information from #{@account_file}"
+      @accounts = YAML::load(File.open(@account_file))
+      @tracker = CloudCostTracker::Tracker.new(
+        @accounts, {:logger => @log, :delay => @opts[:delay]}
+      )
+    end
+
+    def go
+      @tracker.start
+      while true do
+        sleep 30   # Loop forever
+        #@log.info "Total resources = #{@tracker['*::*::*::*'].count}"
+      end
+    end
+
+    def parse_options
+      @opts = {:log_level  => 'INFO'}
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: tracker [options] DB_CONFIG.YML [ACCOUNTS.YML]"
+        opts.on('-d', '--delay SECONDS', Integer,
+        'Number of seconds between status updates') do |delay|
+          @opts[:delay] = delay
+        end
+        opts.on('-l', '--log-level LEVEL', 'Set logging level') do |log_level|
+          @opts[:log_level] = log_level.upcase
+        end
+        opts.on('-m', '--migrate', 'Update database schema') do
+          @opts[:migrate] = true
+        end
+        opts.on('-h', '--help', 'Display this help message') do
+          puts opts ; exit
+        end
+      end
+      optparse.parse!
+      @log.level = LOG_LVLS[@opts[:log_level]] if LOG_LVLS[@opts[:log_level]]
+      if ARGV.count < 1
+        @log.error "A database config file must be specified"
+        exit 1
+      end
+      if ARGV.count < 2
+        @account_file = "./config/accounts.yml"
+      else
+        @account_file = ARGV[1]
+      end
+    end
+
+    def migrate
+      @log.info "Updating database schema..."
+      migration_dir = File.expand_path('../../db/migrate', __FILE__)
+      ActiveRecord::Migrator.migrate migration_dir
+    end
+
+  end
+end
+
+CloudCostTracker::CloudCostTrackerConsoleApp.new.go

data/cloud_cost_tracker.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cloud_cost_tracker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cloud_cost_tracker"
+  s.version     = CloudCostTracker::VERSION
+  s.authors     = ["Benton Roberts"]
+  s.email       = ["benton@bentonroberts.com"]
+  s.homepage    = "http://github.com/benton/cloud_cost_tracker"
+  s.summary     = %q{Records expenses for cloud computing resources }+
+                  %q{in an ActiveRecord database}
+  s.description = %q{Periodically polls one or more cloud computing accounts }+
+                  %q{using the fog gem, and generates ActiveRecord rows }+
+                  %q{representing BillingRecords for each discovered resource.}
+
+  s.rubyforge_project = "cloud_cost_tracker"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Runtime dependencies
+  s.add_dependency "fog_tracker", '>=0.3.9'
+  s.add_dependency "activerecord", '>=3'
+
+  # Development / Test dependencies
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "ruby_gntp"
+  s.add_development_dependency "sqlite3"
+end

data/config/accounts.example.yml

@@ -0,0 +1,45 @@
+AWS EC2 production account: 
+  :provider: AWS
+  :service: Compute
+  :credentials: 
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :delay: 120
+  :exclude_resources:
+AWS S3 account:
+  :provider: AWS
+  :service: Storage
+  :credentials:
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :delay: 120
+  :exclude_resources:
+#  - :directories # (buckets)
+  - :files # secondary entity - does not work yet
+AWS RDS account:
+  :provider: AWS
+  :service: RDS
+  :credentials:
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :delay: 60
+  :exclude_resources:
+  - :parameters # secondary entity - does not work yet
+AWS Route 53 account:
+  :provider: AWS
+  :service: DNS
+  :credentials:
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :delay: 60
+  :exclude_resources:
+  - :records # secondary entity - does not work yet
+AWS Elasticache account:
+  :provider: AWS
+  :service: Elasticache
+  :credentials:
+    :aws_access_key_id: XXXXXXXXXXXXXXXXXXXX
+    :aws_secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+  :delay: 60
+  :exclude_resources:
+

data/config/billing/compute-aws-servers/us-east-on_demand.yml

@@ -0,0 +1,44 @@
+# Amazon EC2 On-demand instance pricing for the US-East region
+# From http://aws.amazon.com/ec2/pricing/
+---
+unix:
+  # Standard On-Demand Instances
+  m1.small:     8.5
+  m1.medium:    16.0
+  m1.large:     32.0
+  m1.xlarge:    64.0
+  # Micro On-Demand Instances
+  t1.micro:     2.0
+  # Hi-Memory On-Demand Instances
+  m2.xlarge:    45.0
+  m2.2xlarge:   90.0
+  m2.4xlarge:   180.0
+  # Hi-CPU On-Demand Instances
+  c1.medium:    16.5
+  c1.xlarge:    66.0
+  # Cluster Compute Instances
+  cc1.4xlarge:  130.0
+  cc1.8xlarge:  240.0
+  # Cluster GPU Instances
+  cg1.4xlarge:  210.0
+
+windows:
+  # Standard On-Demand Instances
+  m1.small:     11.5
+  m1.medium:    23.0
+  m1.large:     46.0
+  m1.xlarge:    92.0
+  # Micro On-Demand Instances
+  t1.micro:     2.0
+  # Hi-Memory On-Demand Instances
+  m2.xlarge:    57.0
+  m2.2xlarge:   114.0
+  m2.4xlarge:   228.0
+  # Hi-CPU On-Demand Instances
+  c1.medium:    28.5
+  c1.xlarge:    114.0
+  # Cluster Compute Instances
+  cc1.4xlarge:  161.0
+  cc1.8xlarge:  297.0
+  # Cluster GPU Instances
+  cg1.4xlarge:  260.0

data/config/billing/compute-aws-snapshots.yml

@@ -0,0 +1,5 @@
+# Elastic Block Store Snapshot pricing, in cents per GB per month
+# From http://aws.amazon.com/ec2/pricing/
+---
+us-east-1:
+  14.0 # cents per GB per month

data/config/billing/compute-aws-volumes.yml

@@ -0,0 +1,5 @@
+# Elastic Block Store Volume pricing, in cents per GB per month
+# From http://aws.amazon.com/ec2/pricing/
+---
+us-east-1:
+  10.0 # cents per GB per month

data/config/billing/elasticache-aws.yml

@@ -0,0 +1,15 @@
+# Amazon Elasticache On-demand instance pricing by Region
+# From http://aws.amazon.com/elasticache/pricing/
+---
+# These numbers are in cents per hour per node in the cluster
+us-east:
+  # Standard On-Demand Instances
+  cache.m1.small:     9.0
+  cache.m1.large:     36.0
+  cache.m1.xlarge:    72.0
+  # Hi-Memory On-Demand Instances
+  cache.m2.xlarge:    50.5
+  cache.m2.2xlarge:   101.0
+  cache.m2.4xlarge:   202.0
+  # Hi-CPU On-Demand Instances
+  cache.c1.xlarge:    74.0

data/config/billing/rds-aws-servers/us-east-on_demand-mysql.yml

@@ -0,0 +1,26 @@
+# Amazon RDS On-demand MySQL instance pricing for the US-East region
+# From http://aws.amazon.com/rds/pricing/
+---
+# Standard Deployment
+standard:
+  # DB Instance Class (On-Demand)
+  db.t1.micro:      2.5
+  db.m1.small:     10.5
+  db.m1.large:     41.5
+  db.m1.xlarge:    83.0
+  # High-Memory DB Instance Class
+  db.m2.xlarge:    58.5
+  db.m2.2xlarge:   117.0
+  db.m2.4xlarge:   234.0
+
+# Multi-AZ Deployment
+multi_az:
+  # DB Instance Class (On-Demand)
+  db.t1.micro:      5.0
+  db.m1.small:     21.0
+  db.m1.large:     83.0
+  db.m1.xlarge:    166.0
+  # High-Memory DB Instance Class
+  db.m2.xlarge:    117.0
+  db.m2.2xlarge:   234.0
+  db.m2.4xlarge:   468.0

data/config/billing/rds-aws-servers/us-east-on_demand-storage.yml

@@ -0,0 +1,10 @@
+# Amazon RDS storage pricing for the US-East region
+# From http://aws.amazon.com/rds/pricing/
+---
+# Standard Deployment
+standard:
+  10.0 # cents per GB per month
+
+# Multi-AZ Deployment
+multi_az:
+  20.0 # cents per GB per month

data/config/billing/storage-aws-directories.yml

@@ -0,0 +1,5 @@
+# Elastic S3 bucket/object pricing, in cents per GB per month
+# From http://aws.amazon.com/s3/#pricing
+---
+us-east-1:
+  9.3 # cents per GB per month

data/config/database.example.yml

@@ -0,0 +1,18 @@
+development:
+  username: root
+  pool: 10             # Best to use at lease one connection per tracked account
+  timeout: 10000       # Leave this nice and long
+  adapter: sqlite3
+  database: db/cloud_cost_tracker_development.sqlite3
+test:
+  username: root
+  pool: 10             # Best to use at lease one connection per tracked account
+  timeout: 10000       # Leave this nice and long
+  adapter: sqlite3
+  database: db/cloud_cost_tracker_test.sqlite3
+production:
+  username: root
+  pool: 10             # Best to use at lease one connection per tracked account
+  timeout: 10000       # Leave this nice and long
+  adapter: sqlite3
+  database: db/cloud_cost_tracker_production.sqlite3

data/db/migrate/20120118000000_create_billing_records.rb

@@ -0,0 +1,22 @@
+class CreateBillingRecords < ActiveRecord::Migration
+  def self.up
+    create_table :billing_records do |t|
+      t.string :provider
+      t.string :service
+      t.string :account
+      t.string :resource_id
+      t.string :billing_type
+      t.datetime :start_time
+      t.datetime :stop_time
+      t.decimal :cost_per_hour, :scale => 10, :precision => 20
+      t.decimal :total_cost, :scale => 10, :precision => 20
+      t.string :resource_type
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :billing_records
+  end
+end

data/db/migrate/20120119000000_create_billing_codes.rb

@@ -0,0 +1,20 @@
+class CreateBillingCodes < ActiveRecord::Migration
+  def self.up
+    create_table :billing_codes do |t|
+      t.string :key,    :size => 512, :null => false
+      t.string :value,  :size => 512
+    end
+
+    create_table :billing_records_codes, :id => false do |t|
+      t.integer :billing_record_id, :null => false
+      t.integer :billing_code_id,   :null => false
+    end
+
+  end
+
+  def self.down
+    drop_table :billing_codes
+    drop_table :billing_records_codes
+  end
+
+end

data/lib/cloud_cost_tracker/billing/account_billing_policy.rb

@@ -0,0 +1,106 @@
+module CloudCostTracker
+  module Billing
+    # Implements the logic for billing all resources in a single account.
+    # Initializes the necessary ResourceBillingPolicy objects, sorts the
+    # resources by policy, and calls get_cost_for_duration twice on each
+    # resource's policy to compute the charges.
+    class AccountBillingPolicy
+
+      # Creates an object that implements the default account billing policy
+      # @param [Array <Fog::Model>] resources the resources to bill for
+      # @param [Hash] options optional parameters:
+      #  - :logger - a Ruby Logger-compatible object
+      def initialize(resources, options={})
+        @log = options[:logger] || FogTracker.default_logger
+        setup_resource_billing_agents(resources)
+        # Initialize data structures for caching costs
+        # the hourly cost for each resource, and billing agent
+        @hourly_cost  = Hash.new # @hourly_cost[resource][agent]
+        # the total cost for each resource, and billing agent
+        @total_cost   = Hash.new # @total_cost[resource][agent]
+        resources.each do |resource|
+          @hourly_cost[resource] ||= Hash.new
+          @total_cost[resource]  ||= Hash.new
+        end
+        @account = resources.first.tracker_account # Save account info
+      end
+
+      # An initializer called by the framework once per billing cycle.
+      # Override this method if you need to perform high-latency operations,
+      # like network transactions, that should not be performed per-resource.
+      def setup(resources) ; end
+
+      # Defines the default method for billing all resources
+      def bill_for(resources)
+        return if resources.empty?
+        setup_resource_billing_agents(resources)
+        delay         = @account[:delay].to_i
+        bill_end      = Time.now
+        bill_start    = @account[:preceeding_update_time] || (bill_end - delay)
+        bill_duration = bill_end - bill_start
+        # calculate the hourly and total cost for all resources, by type
+        @agents.keys.each do |resource_class|
+          collection = resources.select {|r| r.class == resource_class}
+          collection_name = collection.first.collection.class.name.split('::').last
+          @log.info "Computing costs for #{collection.size}"+
+            " #{collection_name} in account #{@account[:name]}"
+          collection.each do |resource|
+            @log.debug "Computing costs for #{resource.tracker_description}"+
+              " in account #{@account[:name]}"
+            @agents[resource.class].each do |billing_agent|
+              @total_cost[resource][billing_agent] = billing_agent.
+                get_cost_for_duration(resource, bill_duration).round(PRECISION)
+              @hourly_cost[resource][billing_agent] = billing_agent.
+                get_cost_for_duration(resource, SECONDS_PER_HOUR).round(PRECISION)
+            @log.debug "Computed costs for #{resource.tracker_description}"+
+              " in account #{@account[:name]}"
+            end
+          end
+          @log.info "Computed costs for #{collection.size}"+
+            " #{collection_name} in account #{@account[:name]}"
+        end
+        write_records_for(resources, bill_start, bill_end)
+      end
+
+      private
+
+      # Writes the billing records - @total_cost and @total_cost must be populated
+      # @param [Array <Fog::Model>] resources the resources to write records for
+      # @param [Time] start_time the start time for any new BillingRecords
+      def write_records_for(resources, start_time, end_time)
+        #ActiveRecord::Base.connection_pool.with_connection do
+          # Write BillingRecords for all resources, by type
+          @agents.keys.each do |resource_class|
+            collection = resources.select {|r| r.class == resource_class}
+            collection_name = collection.first.collection.class.name.split('::').last
+            @log.info "Writing billing records for #{collection.size} "+
+              "#{collection_name} in account #{@account[:name]}"
+            collection.each do |resource|
+              @agents[resource.class].each do |billing_agent|
+                billing_agent.write_billing_record_for(resource,
+                  @hourly_cost[resource][billing_agent],
+                  @total_cost[resource][billing_agent],
+                  start_time, end_time
+                )
+              end
+            end
+            @log.info "Wrote billing records for #{collection.size} "+
+              "#{collection_name} in account #{@account[:name]}"
+          end
+        #end
+      end
+
+      # Builds a Hash of BillingPolicy agents, indexed by resource Class name
+      def setup_resource_billing_agents(resources)
+        @agents = Hash.new
+        ((resources.collect {|r| r.class}).uniq).each do |resource_class|
+          @agents[resource_class] = CloudCostTracker::create_billing_agents(
+            resource_class, {:logger => @log})
+          @agents[resource_class].each {|agent| agent.setup(resources)}
+          @agents.delete(resource_class) if @agents[resource_class].empty?
+        end
+      end
+
+    end
+  end
+end