sunburst 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21354f28529b35ce4d5897120e0f0b37f3ace979705c9d80f746fc2f55e55444
-  data.tar.gz: 8bf865f98151f931e009bf9c8ee0c19397a7cdc3c5c3406c8ac5273f9743963f
+  metadata.gz: 62930035c73348f9b91a1df8e2a94813772dff662770f86f52101f37cf436fea
+  data.tar.gz: a9eba0746892376fdb9cf49cb8ee63408b8a2b2061bfe466edf9d542a0ed83e4
 SHA512:
-  metadata.gz: b23ae54f7a5d19b065c172ea24d9a9df6e81c048ff07a56b770f8d6abe1765cd78971e8604c5f05179d27b9410d8b23997076c79fc56360f69ca2c76bfb72f80
-  data.tar.gz: dd542f7f462a637e909dd3d1f84e59f2adcc3a184fd0a67287d56228f4a5fd4c757a0950e8294825642a6f26462ffefef7ed51435acbb833f19b31d35ae20791
+  metadata.gz: de1c87d3a1c8602ab28f16bffdf6a2b4d1d1fae473ee4b294110b61fe580760afb3faabe6d7b8eae63a69e61b7cfa6e43b25641bef0f0d808638211119c8f161
+  data.tar.gz: 2a2cdc0f891f1df34c533355a38875ae42e314b94d24c79dda270b4d2fe8f155b9a645b54c3ebe4931babfbc34bf7aa6a86dccc1160fad53c617e782958b4d5c

data/exe/sunburst

@@ -1,5 +1,9 @@
-require 'sunburst'
+#!/usr/bin/env ruby
+# Frozen_String_Literal: true
+
+$-v = true
 STDOUT.sync = STDIN.sync = true
+require 'sunburst'
 
 def help
 	puts <<~EOF
@@ -13,18 +17,40 @@ def help
 		Arguments:
 		\s\s\s\s--time=N\s\s\s\s\s\s\s\s\s\sRun the program for N seconds
 		\s\s\s\s-h | --help\s\s\s\s\s\s\sShow this help section
+		\s\s\s\s-p | --progress\s\s\sShow realtime stats of the process
 		\s\s\s\s--humanize\s\s\s\s\s\s\s\sHuman readable memory units
 
 		Example:
 		\s\s\s\ssunburst echo hello world --time=0.05 --humanize
 		\s\s\s\ssunburst "echo hello world" --time=0.05 --humanize
 		\s\s\s\ssunburst "ruby -e 'while true do end'" --time=3 --humanize
-		\s\s\s\ssunburst "ruby -e 'p :Hello'" --time=3 --humanize
+		\s\s\s\ssunburst "ruby -e 'p :Hello'" --time=3
+		\s\s\s\ssunburst "while : ; do : ; done" --time=3 --humanize --progress
+
 	EOF
 
 	exit 0
 end
 
+def splitter(sub = 8)
+	width = Sunburst.win_width
+	puts ?\n, ?-.*(width - sub).center(width)
+end
+
+def convert_bytes(mem)
+	if mem >= 10 ** 12
+		"#{"%06.3f" % mem.fdiv(10 ** 12)} TB"
+	elsif mem >= 10 ** 9
+		"#{"%06.3f" % mem.fdiv(10 ** 9)} GB"
+	elsif mem >= 10 ** 6
+		"#{"%06.3f" % mem.fdiv(10 ** 6)} MB"
+	elsif mem >= 10 ** 3
+		"#{"%06.3f" % mem.fdiv(10 ** 3)} KB"
+	else
+		"#{"%06.3f" % mem} Bytes"
+	end
+end
+
 help if ARGV.any? { |x| x[/^\-(\-help|h)$/] }
 
 time_arg = ARGV.find { |x| x[/^\-\-time=[0-9]+\.?[0-9]*$/] }
@@ -35,46 +61,171 @@ _human_readable = ARGV.find { |x| x[/^\-\-humanize$/] }
 ARGV.delete(_human_readable) if _human_readable
 human_readable = _human_readable
 
+_progress = ARGV.find { |x| x[/^\-(\-progress|p)$/] }
+ARGV.delete(_progress) if _progress
+progress = _progress
+
 command = ARGV.join(' ')
 
 help if command.empty?
 
 puts %Q(:: Running "#{command}" for #{time || 'infinite'} seconds)
-puts ?- * Sunburst.win_width
 
 begin
-	data = Sunburst.measure(command: command, time: time, sleep_time: 0.0001)
+	message = if progress
+		"\e[4mLogging Stats, Ignoring Standard Output and Error\e[0m"
+	else
+		"\e[4mLogging Standard Output and Error\e[0m"
+	end
 
-	puts ?- * Sunburst.win_width
-	puts ":: Total Execution Time: #{data[:execution_time]} seconds"
-	puts ":: CPU Time: #{data[:cpu_time]} second#{?s if data[:cpu_time] != 1}"
+	puts "\e[38;2;243;156;18m#{message.center(Sunburst.win_width + 6)}\e[0m"
 
-	mem = data[:memory]
+	data = if progress
+		if human_readable
+			Sunburst.measure(command: command, time: time, sleep_time: 0.0001) { |exec_t, cpu_t, mem, threads, state, cpu_u|
+				print "\e[2K\r:: "\
+				"Exec T: #{"%05.2f" % exec_t}s | "\
+				"CPU T: #{"%05.2f" % cpu_t}s | "\
+				"Mem: #{convert_bytes(mem)} | "\
+				"Threads: #{threads} | "\
+				"State: #{state} | "\
+				"CPU U: #{cpu_u}\e[s\r\e[u"
+			}
+		else
+			Sunburst.measure(command: command, time: time, sleep_time: 0.0001) { |exec_t, cpu_t, mem, threads, state, cpu_u|
+				print "\e[2K\r:: "\
+				"Exec T: #{"%05.2f" % exec_t} | "\
+				"CPU T: #{"%05.2f" % cpu_t} | "\
+				"Mem: #{"%2d" % mem} | "\
+				"Threads: #{threads} | "\
+				"State: #{state} | "\
+				"CPU U: #{cpu_u}\e[s\r\e[u"
+			}
+		end
+	else
+		Sunburst.measure(command: command, time: time, sleep_time: 0.0001)
+	end
+
+	print "\e[38;2;243;156;18m"
+	splitter()
+	print "\e[0m"
+
+	exec_time = data[:execution_time]
+	cpu_time = data[:cpu_time]
+	percent_time = exec_time == 0 ? 0 : cpu_time.*(100).fdiv(exec_time)
+
+	style = +"\e[1;"
+	style << if percent_time > 75
+		"38;2;230;80;70m"
+	elsif percent_time > 50
+		"38;2;45;125;255m"
+	elsif percent_time > 25
+		"38;2;255;225;0m"
+	else
+		"38;2;40;175;95m"
+	end
+
+	puts ":: Total Execution Time: #{data[:execution_time]} seconds\e[0m"
 
+	percent_time_mesg = exec_time == 0 ? 100 : percent_time
+	puts ":: Total CPU Time: #{style}#{cpu_time}\e[0m second#{?s if cpu_time != 1} (#{"%05.2f" % percent_time_mesg}% exec time)"
+
+	mem = data[:memory]
 	if mem
+		percent_mem = mem.*(100).fdiv(Sunburst.total_ram)
+
+		style = +"\e[1;"
+		style << if percent_mem > 50
+			"38;2;230;80;70m"
+		elsif percent_mem > 30
+			"38;2;45;125;255m"
+		elsif percent_mem > 10
+			"38;2;255;225;0m"
+		else
+			"38;2;40;175;95m"
+		end
+
 		if human_readable
-			mem_text = if mem >= 10 ** 12
-				"#{mem.fdiv(10 ** 12).round(3)} TB"
-			elsif mem >= 10 ** 9
-				"#{mem.fdiv(10 ** 9).round(3)} GB"
-			elsif mem >= 10 ** 6
-				"#{mem.fdiv(10 ** 6).round(3)} MB"
-			elsif mem >= 10 ** 3
-				"#{mem.fdiv(10 ** 3).round(3)} KB"
-			else
-				"#{mem} Bytes"
-			end
-
-			puts ":: Memory usage: #{mem_text}"
+			mem_text = convert_bytes(mem)
+
+			puts ":: Memory Usage During Exit: #{style}#{mem_text}\e[0m (#{percent_mem.round(3)}% system mem)"
+		else
+			puts ":: Memory Usage During Exit: #{style}#{mem} bytes\e[0m (#{percent_mem.round(3)}% system mem)"
+		end
+	else
+		puts ":: The memory Usage Can't be Logged."
+	end
+
+	avg_mem = data[:avg_mem]
+	if avg_mem
+		if human_readable
+			puts ":: Avg. Memory Usage: #{style}#{convert_bytes(avg_mem)}\e[0m (#{percent_mem.round(3)}% system mem)"
+		else
+			puts ":: Avg. Memory Usage: #{style}#{avg_mem}\e[0m (#{percent_mem.round(3)}% system mem)"
+		end
+	else
+		puts ":: The Average Memory Usage can't be Logged."
+	end
+
+	max_mem = data[:max_memory]
+	if max_mem
+		percent_mem = max_mem.*(100).fdiv(Sunburst.total_ram)
+
+		style = +"\e[1;"
+		style << if percent_mem > 50
+			"38;2;230;80;70m"
+		elsif percent_mem > 30
+			"38;2;45;125;255m"
+		elsif percent_mem > 10
+			"38;2;255;225;0m"
+		else
+			"38;2;40;175;95m"
+		end
+
+		if human_readable
+			mem_text = convert_bytes(max_mem)
+
+			puts ":: Max Memory Usage: #{style}#{mem_text}\e[0m (#{percent_mem.round(3)}% system mem)"
 		else
-			puts ":: Memory usage: #{mem} bytes"
+			puts ":: Max Memory Usage: #{style}#{max_mem} bytes\e[0m (#{percent_mem.round(3)}% system mem)"
 		end
 	else
-		puts ":: The memory usage can't be logged."
+		puts ":: The max memory Usage can't be logged."
+	end
+
+	avg_cpu_usage = data[:avg_cpu_usage]
+	if avg_cpu_usage
+		puts ":: Avg. CPU Usage: #{style}#{avg_cpu_usage}\e[0m"
+	else
+		puts ":: The Avg. CPU Usage Can't be Logged"
+	end
+
+	max_cpu_usage = data[:max_cpu_usage]
+	if max_cpu_usage
+		puts ":: Max CPU Usage: #{style}#{max_cpu_usage}\e[0m"
+	else
+		puts ":: The Max CPU Usage Can't be Logged"
 	end
+
+	max_threads = data[:max_threads]
+	style = +"\e[1;"
+	style << if max_threads > 16
+		"38;2;230;80;70m"
+	elsif max_threads > 8
+		"38;2;45;125;255m"
+	elsif max_threads > 4
+		"38;2;255;225;0m"
+	else
+		"38;2;40;175;95m"
+	end
+
+	puts ":: Max Threads: #{style}#{max_threads}\e[0m"
+
 rescue Errno::ENOENT
 	puts "sunburst: #{command}: command not found"
-	puts ?- * Sunburst.win_width
+	puts ?\n, ?- * Sunburst.win_width
+rescue Interrupt
+	puts "\n\e[2KInterrupt Received"
 rescue StandardError
-	puts "$!.full_message"
+	puts $!.full_message
 end

data/ext/stats/stats.c

@@ -2,11 +2,12 @@
 #include <unistd.h>
 #include <time.h>
 #include <sys/ioctl.h>
+#include <sys/sysinfo.h>
 
 unsigned int PAGESIZE ;
 unsigned int TICKS ;
 
-VALUE statm_memory(VALUE obj, VALUE pid) {
+VALUE statm_memory(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
 
@@ -26,41 +27,80 @@ VALUE statm_memory(VALUE obj, VALUE pid) {
 	return UINT2NUM(v) ;
 }
 
-VALUE ps_times(VALUE obj, VALUE pid) {
+VALUE ps_stat(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
-	if (_pid < 0) return Qnil ;
+	if (_pid < 0) return rb_str_new_cstr("") ;
 
 	char _path[22] ;
 	sprintf(_path, "/proc/%d/stat", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
-	if (!f) return Qnil ;
 
-	unsigned long utime, stime ;
+	if (!f) return rb_ary_new() ;
+
+	// For this info
+	// follow https://man7.org/linux/man-pages/man5/proc.5.html
+	char state[1] ;
+	int ppid, processor ;
+	long unsigned utime, stime ;
+	long num_threads ;
+	long long unsigned starttime ;
+
+	char status = fscanf(
+		f, "%*llu (%*[^)]%*[)] %1s "
+		"%d %*d %*d %*d %*d %*u "
+		"%*lu %*lu %*lu %*lu %lu %lu "
+		"%*ld %*ld %*ld %*ld %ld %*ld %ld",
+		&state, &ppid, &utime, &stime, &num_threads, &starttime
+	) ;
 
-	char status = fscanf(f, "%*llu (%*[^)]%*[)] %*c %*d %*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu %lu %lu", &utime, &stime) ;
 	fclose(f) ;
 
-	if (status != 2) return Qnil ;
-	float total_time = (utime + stime) / (float)TICKS ;
+	if (status != 6) return rb_ary_new() ;
+
+	return rb_ary_new_from_args(6,
+		INT2NUM(ppid),
+		ULONG2NUM(utime),
+		ULONG2NUM(stime),
+		LONG2NUM(num_threads),
+		rb_str_new(state, 1),
+		ULL2NUM(starttime)
+	) ;
+}
 
-	return rb_float_new(total_time) ;
+VALUE nProcessors(volatile VALUE obj) {
+	int coreCount = sysconf(_SC_NPROCESSORS_CONF) ;
+	return (coreCount == -1) ? Qnil : INT2NUM(coreCount) ;
 }
 
-VALUE clock_monotonic(VALUE obj) {
+VALUE clock_monotonic(volatile VALUE obj) {
 	struct timespec tv ;
 	clock_gettime(CLOCK_MONOTONIC, &tv) ;
-	long double time = tv.tv_sec + tv.tv_nsec / 1000000000.0 ;
+	float time = tv.tv_sec + tv.tv_nsec / 1000000000.0 ;
 
 	return rb_float_new(time) ;
 }
 
-VALUE winWidth(VALUE obj) {
+VALUE winWidth(volatile VALUE obj) {
 	struct winsize w ;
 	ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) ;
 	return INT2NUM(w.ws_col) ;
 }
 
+VALUE totalRAM(volatile VALUE obj) {
+	struct sysinfo buf ;
+	char status = sysinfo(&buf) ;
+
+	if (status != 0) return Qnil ;
+
+	return rb_funcall(
+		ULONG2NUM(buf.totalram),
+		rb_intern("*"),
+		1,
+		ULONG2NUM(buf.mem_unit)
+	) ;
+}
+
 void Init_stats() {
 	PAGESIZE = sysconf(_SC_PAGESIZE) ;
 	TICKS = sysconf(_SC_CLK_TCK) ;
@@ -70,8 +110,11 @@ void Init_stats() {
 	rb_define_const(sunburst, "TICKS", UINT2NUM(TICKS)) ;
 
 	rb_define_module_function(sunburst, "get_mem", statm_memory, 1) ;
-	rb_define_module_function(sunburst, "get_times", ps_times, 1) ;
 	rb_define_module_function(sunburst, "clock_monotonic", clock_monotonic, 0) ;
 
 	rb_define_module_function(sunburst, "win_width", winWidth, 0) ;
+	rb_define_module_function(sunburst, "ps_stat", ps_stat, 1) ;
+
+	rb_define_module_function(sunburst, "total_ram", totalRAM, 0) ;
+	rb_define_module_function(sunburst, "nprocessors", nProcessors, 0) ;
 }

data/lib/sunburst/sunburst.rb

@@ -1,41 +1,168 @@
 module Sunburst
+	def self.get_stats(pid)
+		stats = Sunburst.ps_stat(pid)
+
+		if stats.empty?
+			Process.kill(9, pid)
+			fail RuntimeError, 'Something horribly wrong happened! Exiting.'
+		end
+
+		stats
+	end
+
+	def self.calculate_cpu_usage(pid, sleep_time)
+		uptime_file = '/proc/uptime'.freeze
+
+		unless File.readable?(uptime_file)
+			sleep(sleep_time)
+			return nil
+		end
+
+		ticks = Sunburst::TICKS
+		stat = Sunburst.ps_stat(pid)
+		uptime = IO.read('/proc/uptime').to_f
+
+		if stat.empty?
+			sleep(sleep_time)
+			return nil
+		end
+
+		utime, stime, starttime = *stat.values_at(1, 2, 5).map(&:to_f)
+		uptime *= ticks
+
+		total_time = utime + stime
+		idle1 = uptime - starttime - total_time
+
+		sleep(sleep_time)
+
+		stat = Sunburst.ps_stat(pid)
+		uptime = IO.read('/proc/uptime').to_f
+		return nil if stat.empty?
+
+		utime2, stime2, starttime2 = *stat.values_at(1, 2, 5).map(&:to_f)
+		uptime *= ticks
+
+		total_time2 = utime2 + stime2
+		idle2 = uptime - starttime2 - total_time2
+
+		totald = idle2.+(total_time2).-(idle1 + total_time)
+		cpu_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(Sunburst.nprocessors)
+
+		cpu_u > 100 ? 100.0 : cpu_u
+	end
+
 	def self.measure(command:, time: nil, sleep_time: 0.001)
-		r = {execution_time: nil, cpu_time: nil, memory: nil}
+		progress = block_given?
+
+		r = {
+			execution_time: nil, cpu_time: nil,
+			memory: nil, max_threads: nil,
+			avg_mem: nil, max_memory: nil, state: nil, last_state: nil,
+			avg_cpu_usage: nil, max_cpu_usage: nil
+		}
 
 		IO.popen(command) { |x|
 			time1 = Sunburst.clock_monotonic
 			pid = x.pid
 
-			t = Thread.new {
-				print x.readpartial(4096) until x.eof?
+			t = if progress
+				Thread.new { }
+			else
+				Thread.new { print x.readpartial(4096) until x.eof? }
+			end
+
+			cpu_usage = 0
+			max_cpu_usage = 0
+			cpu_usage_sum = 0
+			cpu_usage_measure_count = 0
+
+			Thread.new {
+				while true
+					_cpu_usage = calculate_cpu_usage(pid, 0.25)
+
+					if _cpu_usage
+						cpu_usage = "%05.2f%%".freeze % _cpu_usage
+						cpu_usage_sum += _cpu_usage
+						cpu_usage_measure_count += 1
+
+						max_cpu_usage = _cpu_usage if _cpu_usage > max_cpu_usage
+					else
+						cpu_usage = ?X.freeze
+					end
+
+				end
 			}
 
 			last_mem = 0
+			max_threads = 0
+			max_mem = 0
+			last_state = nil
+
+			avg_mem = 0
+			mem_measure_count = 0
 
 			while true
 				_last_mem = Sunburst.get_mem(pid)
 
 				break if (time && Sunburst.clock_monotonic - time1 > time) || _last_mem == 0
 				last_mem = _last_mem
+				max_mem = last_mem if max_mem < _last_mem
+
+				avg_mem += _last_mem
+				mem_measure_count += 1
+
+				# Get stats
+				stats = get_stats(pid)
+				_threads = stats[3]
+				max_threads = _threads if max_threads < _threads
+				last_state = stats[4]
+
+				cpu_time = stats[1].+(stats[2]).fdiv(Sunburst::TICKS)
+
+				if progress
+					yield(
+						Sunburst.clock_monotonic.-(time1),
+						stats[1].+(stats[2]).fdiv(Sunburst::TICKS),
+						_last_mem * Sunburst::PAGESIZE,
+						_threads,
+						last_state,
+						cpu_usage
+					)
+				end
 
 				sleep(sleep_time)
 			end
 
 			time2 = Sunburst.clock_monotonic
 
-			# Get CPU Time
-			cpu_time = Sunburst.get_times(pid).truncate(5)
+			# Get Stats
+			stats = get_stats(pid)
+			cpu_time = stats[1].+(stats[2]).fdiv(Sunburst::TICKS)
+
+			_threads = stats[3]
+			max_threads = _threads if max_threads < _threads
 
-			# Get Memory Usage
 			_last_mem = Sunburst.get_mem(pid)
+			max_mem = _last_mem if max_mem < _last_mem
 			last_mem = _last_mem unless _last_mem == 0
 
+			state = stats[4]
+
 			t.kill
 			Process.kill(9, pid)
 
-			r[:execution_time] = time2.-(time1).truncate(5)
 			r[:cpu_time] = cpu_time
+			r[:max_threads] = max_threads unless max_threads == 0
 			r[:memory] = last_mem * Sunburst::PAGESIZE if last_mem > 0
+			r[:max_memory] = max_mem * Sunburst::PAGESIZE if last_mem > 0
+			r[:avg_mem] =  (avg_mem * Sunburst::PAGESIZE) / mem_measure_count if mem_measure_count > 0
+
+			r[:execution_time] = time2.-(time1).truncate(5)
+			r[:state] = state
+			r[:last_state] = last_state
+
+			r[:avg_cpu_usage] = sprintf("%05.2f%%", cpu_usage_sum / cpu_usage_measure_count) if cpu_usage_measure_count > 0
+			r[:max_cpu_usage] = sprintf("%05.2f%%", max_cpu_usage) if max_cpu_usage > 0
 		}
 
 		r

data/lib/sunburst/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sunburst
-  VERSION = "0.1.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sunburst
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-08 00:00:00.000000000 Z
+date: 2021-09-22 00:00:00.000000000 Z
 dependencies: []
 description: Run a process for a given time, kill it with SIGKILL, report CPU time
   and memory usage
@@ -18,11 +18,9 @@ executables:
 - sunburst
 extensions:
 - ext/stats/extconf.rb
-extra_rdoc_files:
-- README.md
+extra_rdoc_files: []
 files:
 - LICENCE
-- README.md
 - bin/setup
 - exe/sunburst
 - ext/stats/extconf.rb
@@ -49,7 +47,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.13
+rubygems_version: 3.2.21
 signing_key:
 specification_version: 4
 summary: Run a process for a given time, kill it with SIGKILL, report CPU time and

data/README.md

@@ -1,43 +0,0 @@
-# Sunburst
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sunburst`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'sunburst'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install sunburst
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sunburst. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/sunburst/blob/master/CODE_OF_CONDUCT.md).
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Sunburst project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/sunburst/blob/master/CODE_OF_CONDUCT.md).