stackprof 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a10d79a11e17b11b5b706c69c9c5b5546b7fabe9
-  data.tar.gz: 41e9454828e293709c63bb96ecff91530f2fb8da
+  metadata.gz: d8814b67fbdc027a47b2d087321b62ba3f2c5e0b
+  data.tar.gz: f5584eca1af8afa88afd407846b019dedbf33d3d
 SHA512:
-  metadata.gz: 0e3d5900059d2531409bba444a58679e50227d656ab450d5fc04bc8a8fcec9d0055224599369cab3304dbd8366c06957af06978b12f28cb359d8f83455c409ca
-  data.tar.gz: 34c673bbe0c60795d7b97a39d2ab1bace18a6377dfd7c5f63dca31fc2c2e0447e8c420e5663e9b7c61cd11365d5cd4c2e2bc6d0f23f8b414ddb3c7083b82867a
+  metadata.gz: 50d3070d8a4ae606cb90b8e94afdbe4a047abc449a77731ebb9e198dd7fbb4f5e86965bbdba8761f3fbebe01023fca08376b865f84c25dcc7f51d4e7a9752d4c
+  data.tar.gz: 4b0bdc52fdd32bb21b1a10a0061371e2d51ae126cd39c01c6898b2a405f6e2a13dd879e439b610d90fde8661d245f995bcf86063bb76570b2b8ddc793a2bdd2b

data/README.md

@@ -10,10 +10,9 @@ and written as a replacement for [perftools.rb](https://github.com/tmm1/perftool
 in ruby:
 
 ``` ruby
-profile = StackProf.run(mode: :cpu) do
+StackProf.run(mode: :cpu, out: 'tmp/stackprof-cpu-myapp.dump') do
   ...
 end
-File.open('tmp/stackprof-cpu-myapp.dump', 'wb'){ |f| f.write Marshal.dump(profile) }
 ```
 
 via rack:
@@ -63,12 +62,14 @@ $ stackprof tmp/stackprof-cpu-*.dump --method 'Object#present?'
                                     |    22  |   end
 ```
 
+For an experimental version of WebUI reporting of stackprof, see [stackprof-webnav](https://github.com/alisnic/stackprof-webnav)
+
 ### sampling
 
 four sampling modes are supported:
 
-  - :wall (using `ITIMER_REAL` and `SIGALRM`) [default mode]
-  - :cpu (using `ITIMER_PROF` and `SIGPROF`)
+  - :wall (using `ITIMER_REAL` and `SIGALRM`)
+  - :cpu (using `ITIMER_PROF` and `SIGPROF`) [default mode]
   - :object (using `RUBY_INTERNAL_EVENT_NEWOBJ`)
   - :custom (user-defined via `StackProf.sample`)
 

data/bin/stackprof

@@ -13,12 +13,14 @@ parser = OptionParser.new(ARGV) do |o|
 
   o.on('--text', 'Text summary per method (default)'){ options[:format] = :text }
   o.on('--files', 'List of files'){ |f| options[:format] = :files }
-  o.on('--limit=[num]', Integer, 'Limit --text or --files output to N lines'){ |n| options[:limit] = n }
+  o.on('--limit [num]', Integer, 'Limit --text or --files output to N lines'){ |n| options[:limit] = n }
   o.on('--sort-total', "Sort --text or --files output on total samples\n\n"){ options[:sort] = true }
-  o.on('--method=[grep]', 'Zoom into specified method'){ |f| options[:format] = :method; options[:filter] = f }
-  o.on('--file=[grep]', 'Show annotated code for specified file'){ |f| options[:format] = :file; options[:filter] = f }
+  o.on('--method [grep]', 'Zoom into specified method'){ |f| options[:format] = :method; options[:filter] = f }
+  o.on('--file [grep]', 'Show annotated code for specified file'){ |f| options[:format] = :file; options[:filter] = f }
+  o.on('--stackcollapse', 'stackcollapse.pl compatible output (use with flamegraph.pl)'){ options[:format] = :stackcollapse }
   o.on('--callgrind', 'Callgrind output (use with kcachegrind, gprof2dot)'){ options[:format] = :callgrind }
   o.on('--graphviz', "Graphviz output (use with dot)\n\n"){ options[:format] = :graphviz }
+  o.on('--dump', 'Print marshaled profile dump (combine multiple profiles)'){ options[:format] = :dump }
   o.on('--debug', 'Pretty print raw profile data'){ options[:format] = :debug }
 end
 
@@ -27,7 +29,12 @@ parser.abort(parser.help) if ARGV.empty?
 
 reports = []
 while ARGV.size > 0
-  reports << StackProf::Report.new(Marshal.load(IO.binread(ARGV.pop)))
+  begin
+    file = ARGV.pop
+    reports << StackProf::Report.new(Marshal.load(IO.binread(file)))
+  rescue TypeError => e
+    STDERR.puts "** error parsing #{file}: #{e.inspect}"
+  end
 end
 report = reports.inject(:+)
 
@@ -36,10 +43,14 @@ when :text
   report.print_text(options[:sort], options[:limit])
 when :debug
   report.print_debug
+when :dump
+  report.print_dump
 when :callgrind
   report.print_callgrind
 when :graphviz
   report.print_graphviz
+when :stackcollapse
+  report.print_stackcollapse
 when :method
   report.print_method(options[:filter])
 when :file

data/bin/stackprof-flamegraph

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec(File.expand_path("../../vendor/FlameGraph/flamegraph.pl", __FILE__), *ARGV)

data/bin/stackprof-gprof2dot

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec(File.expand_path("../../vendor/gprof2dot/gprof2dot.py", __FILE__), *ARGV)

data/ext/stackprof.c

@@ -2,19 +2,15 @@
 
   stackprof.c - Sampling call-stack frame profiler for MRI.
 
-  $Author$
-  created at: Thu May 30 17:55:25 2013
-
-  NOTE: This extension library is not expected to exist except C Ruby.
-
-  All the files in this distribution are covered under the Ruby's
-  license (see the file COPYING).
+  vim: setl noexpandtab shiftwidth=4 tabstop=8 softtabstop=4
 
 **********************************************************************/
 
 #include <ruby/ruby.h>
 #include <ruby/debug.h>
 #include <ruby/st.h>
+#include <ruby/io.h>
+#include <ruby/intern.h>
 #include <signal.h>
 #include <sys/time.h>
 #include <pthread.h>
@@ -32,6 +28,9 @@ static struct {
     int running;
     VALUE mode;
     VALUE interval;
+    VALUE raw;
+    size_t raw_sample_index;
+    VALUE out;
 
     size_t overall_signals;
     size_t overall_samples;
@@ -44,7 +43,7 @@ static struct {
 
 static VALUE sym_object, sym_wall, sym_cpu, sym_custom, sym_name, sym_file, sym_line;
 static VALUE sym_samples, sym_total_samples, sym_missed_samples, sym_edges, sym_lines;
-static VALUE sym_version, sym_mode, sym_interval, sym_frames;
+static VALUE sym_version, sym_mode, sym_interval, sym_raw, sym_frames, sym_out;
 static VALUE sym_gc_samples, objtracer;
 static VALUE gc_hook;
 static VALUE rb_mStackProf;
@@ -57,7 +56,7 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
 {
     struct sigaction sa;
     struct itimerval timer;
-    VALUE opts = Qnil, mode = Qnil, interval = Qnil;
+    VALUE opts = Qnil, mode = Qnil, interval = Qnil, raw = Qfalse, out = Qfalse;
 
     if (_stackprof.running)
 	return Qfalse;
@@ -67,6 +66,10 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     if (RTEST(opts)) {
 	mode = rb_hash_aref(opts, sym_mode);
 	interval = rb_hash_aref(opts, sym_interval);
+	out = rb_hash_aref(opts, sym_out);
+
+	if (RTEST(rb_hash_aref(opts, sym_raw)))
+	    raw = rb_ary_new();
     }
     if (!RTEST(mode)) mode = sym_wall;
 
@@ -102,8 +105,10 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     }
 
     _stackprof.running = 1;
+    _stackprof.raw = raw;
     _stackprof.mode = mode;
     _stackprof.interval = interval;
+    _stackprof.out = out;
 
     return Qtrue;
 }
@@ -207,7 +212,7 @@ frame_i(st_data_t key, st_data_t val, st_data_t arg)
 }
 
 static VALUE
-stackprof_results(VALUE self)
+stackprof_results(int argc, VALUE *argv, VALUE self)
 {
     VALUE results, frames;
 
@@ -229,7 +234,28 @@ stackprof_results(VALUE self)
     st_free_table(_stackprof.frames);
     _stackprof.frames = NULL;
 
-    return results;
+    if (RTEST(_stackprof.raw)) {
+	rb_hash_aset(results, sym_raw, _stackprof.raw);
+	_stackprof.raw = Qfalse;
+    }
+
+    if (argc == 1)
+	_stackprof.out = argv[0];
+
+    if (RTEST(_stackprof.out)) {
+	VALUE file;
+	if (RB_TYPE_P(_stackprof.out, T_STRING)) {
+	    file = rb_file_open_str(_stackprof.out, "w");
+	} else {
+	    file = rb_io_check_io(_stackprof.out);
+	}
+	rb_marshal_dump(results, file);
+	rb_io_flush(file);
+	_stackprof.out = Qnil;
+	return file;
+    } else {
+	return results;
+    }
 }
 
 static VALUE
@@ -238,7 +264,7 @@ stackprof_run(int argc, VALUE *argv, VALUE self)
     rb_need_block();
     stackprof_start(argc, argv, self);
     rb_ensure(rb_yield, Qundef, stackprof_stop, self);
-    return stackprof_results(self);
+    return stackprof_results(0, 0, self);
 }
 
 static VALUE
@@ -288,12 +314,41 @@ st_numtable_increment(st_table *table, st_data_t key, size_t increment)
 void
 stackprof_record_sample()
 {
-    int num, i;
+    int num, i, n;
+    int raw_mode = RTEST(_stackprof.raw);
     VALUE prev_frame = Qnil;
+    size_t raw_len;
 
     _stackprof.overall_samples++;
     num = rb_profile_frames(0, sizeof(_stackprof.frames_buffer), _stackprof.frames_buffer, _stackprof.lines_buffer);
 
+    if (raw_mode) {
+	int found = 0;
+	raw_len = RARRAY_LEN(_stackprof.raw);
+
+	if (RARRAY_LEN(_stackprof.raw) > 0 && RARRAY_AREF(_stackprof.raw, _stackprof.raw_sample_index) == INT2FIX(num)) {
+	    for (i = num-1, n = 0; i >= 0; i--, n++) {
+		VALUE frame = _stackprof.frames_buffer[i];
+		if (RARRAY_AREF(_stackprof.raw, _stackprof.raw_sample_index + 1 + n) != rb_obj_id(frame))
+		    break;
+	    }
+	    if (i == -1) {
+		RARRAY_ASET(_stackprof.raw, raw_len-1, LONG2NUM(NUM2LONG(RARRAY_AREF(_stackprof.raw, raw_len-1))+1));
+		found = 1;
+	    }
+	}
+
+	if (!found) {
+	    _stackprof.raw_sample_index = raw_len;
+	    rb_ary_push(_stackprof.raw, INT2FIX(num));
+	    for (i = num-1; i >= 0; i--) {
+		VALUE frame = _stackprof.frames_buffer[i];
+		rb_ary_push(_stackprof.raw, rb_obj_id(frame));
+	    }
+	    rb_ary_push(_stackprof.raw, INT2FIX(1));
+	}
+    }
+
     for (i = 0; i < num; i++) {
 	int line = _stackprof.lines_buffer[i];
 	VALUE frame = _stackprof.frames_buffer[i];
@@ -346,6 +401,7 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 static void
 stackprof_newobj_handler(VALUE tpval, void *data)
 {
+    /* TODO: implement interval */
     _stackprof.overall_signals++;
     stackprof_job_handler(0);
 }
@@ -372,6 +428,11 @@ frame_mark_i(st_data_t key, st_data_t val, st_data_t arg)
 static void
 stackprof_gc_mark(void *data)
 {
+    if (RTEST(_stackprof.raw))
+	rb_gc_mark(_stackprof.raw);
+    if (RTEST(_stackprof.out))
+	rb_gc_mark(_stackprof.out);
+
     if (_stackprof.frames)
 	st_foreach(_stackprof.frames, frame_mark_i, 0);
 }
@@ -427,6 +488,8 @@ Init_stackprof(void)
     sym_version = ID2SYM(rb_intern("version"));
     sym_mode = ID2SYM(rb_intern("mode"));
     sym_interval = ID2SYM(rb_intern("interval"));
+    sym_raw = ID2SYM(rb_intern("raw"));
+    sym_out = ID2SYM(rb_intern("out"));
     sym_frames = ID2SYM(rb_intern("frames"));
 
     gc_hook = Data_Wrap_Struct(rb_cObject, stackprof_gc_mark, NULL, NULL);
@@ -437,7 +500,7 @@ Init_stackprof(void)
     rb_define_singleton_method(rb_mStackProf, "run", stackprof_run, -1);
     rb_define_singleton_method(rb_mStackProf, "start", stackprof_start, -1);
     rb_define_singleton_method(rb_mStackProf, "stop", stackprof_stop, 0);
-    rb_define_singleton_method(rb_mStackProf, "results", stackprof_results, 0);
+    rb_define_singleton_method(rb_mStackProf, "results", stackprof_results, -1);
     rb_define_singleton_method(rb_mStackProf, "sample", stackprof_sample, 0);
 
     rb_autoload(rb_mStackProf, rb_intern_const("Report"), "stackprof/report.rb");

data/lib/stackprof/middleware.rb

@@ -31,13 +31,14 @@ module StackProf
       attr_accessor :enabled, :mode, :interval, :path
       alias enabled? enabled
 
-      def save
+      def save(filename = nil)
         if results = StackProf.results
           FileUtils.mkdir_p(Middleware.path)
-          filename = "stackprof-#{results[:mode]}-#{Process.pid}-#{Time.now.to_i}.dump"
-          File.open(File.join(Middleware.path, filename), 'wb') do |f| 
+          filename ||= "stackprof-#{results[:mode]}-#{Process.pid}-#{Time.now.to_i}.dump"
+          File.open(File.join(Middleware.path, filename), 'wb') do |f|
             f.write Marshal.dump(results)
           end
+          filename
         end
       end
 

data/lib/stackprof/report.rb

@@ -63,6 +63,22 @@ module StackProf
       pp @data
     end
 
+    def print_dump
+      puts Marshal.dump(@data.reject{|k,v| k == :files })
+    end
+
+    def print_stackcollapse
+      raise "profile does not include raw samples" unless raw = data[:raw]
+
+      while len = raw.shift
+        frames = raw.slice!(0, len)
+        weight = raw.shift
+
+        print frames.map{ |a| data[:frames][a][:name] }.join(';')
+        puts " #{weight}"
+      end
+    end
+
     def print_graphviz(filter = nil, f = STDOUT)
       if filter
         mark_stack = []
@@ -161,7 +177,7 @@ module StackProf
         f.printf "%s (%s:%d)\n", info[:name], file, line
         f.printf "  samples: % 5d self (%2.1f%%)  /  % 5d total (%2.1f%%)\n", info[:samples], 100.0*info[:samples]/overall_samples, info[:total_samples], 100.0*info[:total_samples]/overall_samples
 
-        if (callers = data[:frames].map{ |id, other| [other[:name], other[:edges][frame]] if other[:edges] && other[:edges].include?(frame) }.compact).any?
+        if (callers = callers_for(frame)).any?
           f.puts "  callers:"
           callers = callers.sort_by(&:last).reverse
           callers.each do |name, weight|
@@ -203,6 +219,15 @@ module StackProf
 
     private
 
+    def root_frames
+      frames.select{ |addr, frame| callers_for(addr).size == 0  }
+    end
+
+    def callers_for(addr)
+      @callers_for ||= {}
+      @callers_for[addr] ||= data[:frames].map{ |id, other| [other[:name], other[:edges][addr]] if other[:edges] && other[:edges].include?(addr) }.compact
+    end
+
     def source_display(f, file, lines, range=nil)
       File.readlines(file).each_with_index do |code, i|
         next unless range.nil? || range.include?(i)

data/stackprof.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'stackprof'
-  s.version = '0.2.2'
+  s.version = '0.2.3'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'
@@ -11,6 +11,8 @@ Gem::Specification.new do |s|
 
   s.bindir = 'bin'
   s.executables << 'stackprof'
+  s.executables << 'stackprof-flamegraph'
+  s.executables << 'stackprof-gprof2dot'
 
   s.summary = 'sampling callstack-profiler for ruby 2.1+'
   s.description = 'stackprof is a fast sampling profiler for ruby code, with cpu, wallclock and object allocation samplers.'

data/test/test_stackprof.rb

@@ -1,6 +1,7 @@
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'test/unit'
+require 'tempfile'
 
 class StackProfTest < Test::Unit::TestCase
   def test_info
@@ -86,6 +87,19 @@ class StackProfTest < Test::Unit::TestCase
     assert_equal [10, 10], frame[:lines][__LINE__-10]
   end
 
+  def test_raw
+    profile = StackProf.run(mode: :custom, raw: true) do
+      10.times do
+        StackProf.sample
+      end
+    end
+
+    raw = profile[:raw]
+    assert_equal 10, raw[-1]
+    assert_equal raw[0] + 2, raw.size
+    assert_equal 'block (2 levels) in StackProfTest#test_raw', profile[:frames][raw[-2]][:name]
+  end
+
   def test_fork
     StackProf.run do
       pid = fork do
@@ -109,6 +123,18 @@ class StackProfTest < Test::Unit::TestCase
     assert_equal 0, profile[:missed_samples]
   end
 
+  def test_out
+    tmpfile = Tempfile.new('stackprof-out')
+    ret = StackProf.run(mode: :custom, out: tmpfile) do
+      StackProf.sample
+    end
+
+    assert_equal tmpfile, ret
+    tmpfile.rewind
+    profile = Marshal.load(tmpfile.read)
+    assert_not_empty profile[:frames]
+  end
+
   def math
     250_000.times do
       2 ** 10

data/vendor/FlameGraph/README

@@ -0,0 +1,134 @@
+Flame Graphs visualize profiled code-paths.
+
+Website: http://www.brendangregg.com/flamegraphs.html
+
+CPU profiling using DTrace, perf_events, SystemTap, or ktap: http://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html
+CPU profiling using XCode Instruments: http://schani.wordpress.com/2012/11/16/flame-graphs-for-instruments/
+CPU profiling using Xperf.exe: http://randomascii.wordpress.com/2013/03/26/summarizing-xperf-cpu-usage-with-flame-graphs/
+Memory profiling: http://www.brendangregg.com/FlameGraphs/memoryflamegraphs.html
+
+These can be created in three steps:
+
+   1. Capture stacks
+   2. Fold stacks
+   3. flamegraph.pl
+
+
+1. Capture stacks
+=================
+Stack samples can be captured using DTrace, perf_events or SystemTap.
+
+Using DTrace to capture 60 seconds of kernel stacks at 997 Hertz:
+
+# dtrace -x stackframes=100 -n 'profile-997 /arg0/ { @[stack()] = count(); } tick-60s { exit(0); }' -o out.kern_stacks
+
+Using DTrace to capture 60 seconds of user-level stacks for PID 12345 at 97 Hertz:
+
+# dtrace -x ustackframes=100 -n 'profile-97 /pid == 12345 && arg1/ { @[ustack()] = count(); } tick-60s { exit(0); }' -o out.user_stacks
+
+Using DTrace to capture 60 seconds of user-level stacks, including while time is spent in the kernel, for PID 12345 at 97 Hertz:
+
+# dtrace -x ustackframes=100 -n 'profile-97 /pid == 12345/ { @[ustack()] = count(); } tick-60s { exit(0); }' -o out.user_stacks
+
+Switch ustack() for jstack() if the application has a ustack helper to include translated frames (eg, node.js frames; see: http://dtrace.org/blogs/dap/2012/01/05/where-does-your-node-program-spend-its-time/).  The rate for user-level stack collection is deliberately slower than kernel, which is especially important when using jstack() as it performs additional work to translate frames.
+
+2. Fold stacks
+==============
+Use the stackcollapse programs to fold stack samples into single lines.  The programs provided are:
+
+- stackcollapse.pl: for DTrace stacks
+- stackcollapse-perf.pl: for perf_events "perf script" output
+- stackcollapse-stap.pl: for SystemTap stacks
+- stackcollapse-instruments.pl: for XCode Instruments
+
+Usage example:
+
+$ ./stackcollapse.pl out.kern_stacks > out.kern_folded
+
+The output looks like this:
+
+unix`_sys_sysenter_post_swapgs 1401
+unix`_sys_sysenter_post_swapgs;genunix`close 5
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf 85
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;c2audit`audit_closef 26
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;c2audit`audit_setf 5
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`audit_getstate 6
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`audit_unfalloc 2
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`closef 48
+[...]
+
+3. flamegraph.pl
+================
+Use flamegraph.pl to render a SVG.
+
+$ ./flamegraph.pl out.kern_folded > kernel.svg
+
+An advantage of having the folded input file (and why this is separate to flamegraph.pl) is that you can use grep for functions of interest. Eg:
+
+$ grep cpuid out.kern_folded | ./flamegraph.pl > cpuid.svg
+
+
+Provided Example
+================
+An example output from DTrace is included, both the captured stacks and
+the resulting Flame Graph. You can generate it yourself using:
+
+$ ./stackcollapse.pl example-stacks.txt | ./flamegraph.pl > example.svg
+
+This was from a particular performance investigation: the Flame Graph
+identified that CPU time was spent in the lofs module, and quantified
+that time.
+
+
+Options
+=======
+See the USAGE message (--help) for options:
+
+USAGE: ./flamegraph.pl [options] infile > outfile.svg
+
+        --titletext             # change title text
+        --width                 # width of image (default 1200)
+        --height                # height of each frame (default 16)
+        --minwidth              # omit smaller functions (default 0.1 pixels)
+        --fonttype              # font type (default "Verdana")
+        --fontsize              # font size (default 12)
+        --countname             # count type label (default "samples")
+        --nametype              # name type label (default "Function:")
+        --colors                # "hot", "mem", "io" palette (default "hot")
+        --hash                  # colors are keyed by function name hash
+        --cp                    # use consistent palette (palette.map)
+    eg,
+        ./flamegraph.pl --titletext="Flame Graph: malloc()" trace.txt > graph.svg
+
+As suggested in the example, flame graphs can process traces of any event,
+such as malloc()s, provided stack traces are gathered.
+
+
+Consistent Palette
+==================
+If you use the --cp option, it will use the $colors selection and randomly
+generate the palette like normal. Any future flamegraphs created using the --cp
+option will use the same palette map. Any new symbols from future flamegraphs
+will have their colors randomly generated using the $colors selection.
+
+If you don't like the palette, just delete the palette.map file.
+
+This allows your to change your colorscheme between flamegraphs to make the
+differences REALLY stand out.
+
+Example:
+
+Say we have 2 captures, one with a problem, and one when it was working
+(whatever "it" is):
+
+cat working.folded | ./flamegraph.pl --cp > working.svg
+# this generates a palette.map, as per the normal random generated look.
+
+cat broken.folded | ./flamegraph.pl --cp --colors mem > broken.svg
+# this svg will use the same palette.map for the same events, but a very
+# different colorscheme for any new events.
+
+Take a look at the demo directory for an example:
+
+palette-example-working.svg
+palette-example-broken.svg