fluentd 0.14.4-x86-mingw32

data/lib/fluent/plugin/buffer/memory_chunk.rb

@@ -0,0 +1,90 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/buffer/chunk'
+
+module Fluent
+  module Plugin
+    class Buffer
+      class MemoryChunk < Chunk
+        def initialize(metadata)
+          super
+          @chunk = ''.force_encoding(Encoding::ASCII_8BIT)
+          @chunk_bytes = 0
+          @adding_bytes = 0
+          @adding_size = 0
+        end
+
+        def concat(bulk, bulk_size)
+          raise "BUG: concatenating to unwritable chunk, now '#{self.state}'" unless self.writable?
+
+          bulk.force_encoding(Encoding::ASCII_8BIT)
+          @chunk << bulk
+          @adding_bytes += bulk.bytesize
+          @adding_size += bulk_size
+          true
+        end
+
+        def commit
+          @size += @adding_size
+          @chunk_bytes += @adding_bytes
+
+          @adding_bytes = @adding_size = 0
+          @modified_at = Time.now
+          true
+        end
+
+        def rollback
+          @chunk.slice!(@chunk_bytes, @adding_bytes)
+          @adding_bytes = @adding_size = 0
+          true
+        end
+
+        def bytesize
+          @chunk_bytes + @adding_bytes
+        end
+
+        def size
+          @size + @adding_size
+        end
+
+        def empty?
+          @chunk.empty?
+        end
+
+        def purge
+          super
+          @chunk = ''.force_encoding("ASCII-8BIT")
+          @chunk_bytes = @size = @adding_bytes = @adding_size = 0
+          true
+        end
+
+        def read
+          @chunk
+        end
+
+        def open(&block)
+          StringIO.open(@chunk, &block)
+        end
+
+        def write_to(io)
+          # re-implementation to optimize not to create StringIO
+          io.write @chunk
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/exec_util.rb

@@ -0,0 +1,22 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/compat/exec_util'
+
+module Fluent
+  # obsolete
+  ExecUtil = Fluent::Compat::ExecUtil
+end

data/lib/fluent/plugin/file_util.rb

@@ -0,0 +1,22 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/compat/file_util'
+
+module Fluent
+  # obsolete
+  FileUtil = Fluent::Compat::FileUtil
+end

data/lib/fluent/plugin/file_wrapper.rb

@@ -0,0 +1,120 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent
+  module FileWrapper
+    def self.open(*args)
+      io = WindowsFile.new(*args).io
+      if block_given?
+        v = yield io
+        io.close
+        v
+      else
+        io
+      end
+    end
+
+    def self.stat(path)
+      f = WindowsFile.new(path)
+      s = f.stat
+      f.close
+      s
+    end
+  end
+
+  module WindowsFileExtension
+    attr_reader :path
+
+    def stat
+      s = super
+      s.instance_variable_set :@ino, @ino
+      def s.ino; @ino; end
+      s
+    end
+  end
+
+  # To open and get stat with setting FILE_SHARE_DELETE
+  class WindowsFile
+    require 'windows/file'
+    require 'windows/error'
+    require 'windows/handle'
+    require 'windows/nio'
+
+    include Windows::Error
+    include Windows::File
+    include Windows::Handle
+    include Windows::NIO
+
+    def initialize(path, mode='r', sharemode=FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE)
+      @path = path
+      @file_handle = INVALID_HANDLE_VALUE
+      @mode = mode
+
+
+      access, creationdisposition, seektoend = case mode.delete('b')
+      when "r" ; [FILE_GENERIC_READ                     , OPEN_EXISTING, false]
+      when "r+"; [FILE_GENERIC_READ | FILE_GENERIC_WRITE, OPEN_ALWAYS  , false]
+      when "w" ; [FILE_GENERIC_WRITE                    , CREATE_ALWAYS, false]
+      when "w+"; [FILE_GENERIC_READ | FILE_GENERIC_WRITE, CREATE_ALWAYS, false]
+      when "a" ; [FILE_GENERIC_WRITE                    , OPEN_ALWAYS  , true]
+      when "a+"; [FILE_GENERIC_READ | FILE_GENERIC_WRITE, OPEN_ALWAYS  , true]
+      else raise "unknown mode '#{mode}'"
+      end
+
+      @file_handle = CreateFile.call(@path, access, sharemode,
+                     0, creationdisposition, FILE_ATTRIBUTE_NORMAL, 0)
+      if @file_handle == INVALID_HANDLE_VALUE
+        err = GetLastError.call
+        if err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND || err == ERROR_ACCESS_DENIED
+          raise SystemCallError.new(2)
+        end
+        raise SystemCallError.new(err)
+      end
+    end
+
+    def close
+      CloseHandle.call(@file_handle)
+      @file_handle = INVALID_HANDLE_VALUE
+    end
+
+    def io
+      fd = _open_osfhandle(@file_handle, 0)
+      raise Errno::ENOENT if fd == -1
+      io = File.for_fd(fd, @mode)
+      io.instance_variable_set :@ino, self.ino
+      io.instance_variable_set :@path, @path
+      io.extend WindowsFileExtension
+      io
+    end
+
+    def ino
+      by_handle_file_information = '\0'*(4+8+8+8+4+4+4+4+4+4)   #72bytes
+
+      unless GetFileInformationByHandle.call(@file_handle, by_handle_file_information)
+        return 0
+      end
+
+      by_handle_file_information.unpack("I11Q1")[11] # fileindex
+    end
+
+    def stat
+      s = File.stat(@path)
+      s.instance_variable_set :@ino, self.ino
+      def s.ino; @ino; end
+      s
+    end
+  end
+end if Fluent.windows?

data/lib/fluent/plugin/filter.rb

@@ -0,0 +1,93 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/base'
+
+require 'fluent/event'
+require 'fluent/log'
+require 'fluent/plugin_id'
+require 'fluent/plugin_helper'
+
+module Fluent
+  module Plugin
+    class Filter < Base
+      include PluginId
+      include PluginLoggerMixin
+      include PluginHelper::Mixin
+
+      helpers :event_emitter
+
+      attr_reader :has_filter_with_time
+
+      def initialize
+        super
+        @has_filter_with_time = has_filter_with_time?
+      end
+
+      def filter(tag, time, record)
+        raise NotImplementedError, "BUG: filter plugins MUST implement this method"
+      end
+
+      def filter_with_time(tag, time, record)
+        raise NotImplementedError, "BUG: filter plugins MUST implement this method"
+      end
+
+      def filter_stream(tag, es)
+        new_es = MultiEventStream.new
+        if @has_filter_with_time
+          es.each do |time, record|
+            begin
+              filtered_time, filtered_record = filter_with_time(tag, time, record)
+              new_es.add(filtered_time, filtered_record) if filtered_time && filtered_record
+            rescue => e
+              router.emit_error_event(tag, time, record, e)
+            end
+          end
+        else
+          es.each do |time, record|
+            begin
+              filtered_record = filter(tag, time, record)
+              new_es.add(time, filtered_record) if filtered_record
+            rescue => e
+              router.emit_error_event(tag, time, record, e)
+            end
+          end
+        end
+        new_es
+      end
+
+      private
+
+      def has_filter_with_time?
+        implmented_methods = self.class.instance_methods(false)
+        # Plugins that override `filter_stream` don't need check,
+        # because they may not call `filter` or `filter_with_time`
+        # for example fluentd/lib/fluent/plugin/filter_record_transformer.rb
+        return nil if implmented_methods.include?(:filter_stream)
+        case
+        when [:filter, :filter_with_time].all? { |e| implmented_methods.include?(e) }
+          raise "BUG: Filter plugins MUST be implemented either `filter` or `filter_with_time`"
+        when implmented_methods.include?(:filter)
+          false
+        when implmented_methods.include?(:filter_with_time)
+          true
+        else
+          raise NotImplementedError, "BUG: Filter plugins MUST be implmented either `filter` or `filter_with_time`"
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/filter_grep.rb

@@ -0,0 +1,75 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/filter'
+require 'fluent/config/error'
+require 'fluent/plugin/string_util'
+
+module Fluent::Plugin
+  class GrepFilter < Filter
+    Fluent::Plugin.register_filter('grep', self)
+
+    REGEXP_MAX_NUM = 20
+
+    (1..REGEXP_MAX_NUM).each {|i| config_param :"regexp#{i}",  :string, default: nil }
+    (1..REGEXP_MAX_NUM).each {|i| config_param :"exclude#{i}", :string, default: nil }
+
+    # for test
+    attr_reader :regexps
+    attr_reader :excludes
+
+    def configure(conf)
+      super
+
+      @regexps = {}
+      (1..REGEXP_MAX_NUM).each do |i|
+        next unless conf["regexp#{i}"]
+        key, regexp = conf["regexp#{i}"].split(/ /, 2)
+        raise ConfigError, "regexp#{i} does not contain 2 parameters" unless regexp
+        raise ConfigError, "regexp#{i} contains a duplicated key, #{key}" if @regexps[key]
+        @regexps[key] = Regexp.compile(regexp)
+      end
+
+      @excludes = {}
+      (1..REGEXP_MAX_NUM).each do |i|
+        next unless conf["exclude#{i}"]
+        key, exclude = conf["exclude#{i}"].split(/ /, 2)
+        raise ConfigError, "exclude#{i} does not contain 2 parameters" unless exclude
+        raise ConfigError, "exclude#{i} contains a duplicated key, #{key}" if @excludes[key]
+        @excludes[key] = Regexp.compile(exclude)
+      end
+    end
+
+    def filter(tag, time, record)
+      result = nil
+      begin
+        catch(:break_loop) do
+          @regexps.each do |key, regexp|
+            throw :break_loop unless ::Fluent::StringUtil.match_regexp(regexp, record[key].to_s)
+          end
+          @excludes.each do |key, exclude|
+            throw :break_loop if ::Fluent::StringUtil.match_regexp(exclude, record[key].to_s)
+          end
+          result = record
+        end
+      rescue => e
+        log.warn "failed to grep events", error: e
+        log.warn_backtrace
+      end
+      result
+    end
+  end
+end

data/lib/fluent/plugin/filter_record_transformer.rb

@@ -0,0 +1,342 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'socket'
+require 'json'
+require 'ostruct'
+
+require 'fluent/plugin/filter'
+require 'fluent/config/error'
+require 'fluent/event'
+require 'fluent/time'
+
+module Fluent::Plugin
+  class RecordTransformerFilter < Fluent::Plugin::Filter
+    Fluent::Plugin.register_filter('record_transformer', self)
+
+    desc 'A comma-delimited list of keys to delete.'
+    config_param :remove_keys, :string, default: nil
+    desc 'A comma-delimited list of keys to keep.'
+    config_param :keep_keys, :string, default: nil
+    desc 'Create new Hash to transform incoming data'
+    config_param :renew_record, :bool, default: false
+    desc 'Specify field name of the record to overwrite the time of events. Its value must be unix time.'
+    config_param :renew_time_key, :string, default: nil
+    desc 'When set to true, the full Ruby syntax is enabled in the ${...} expression.'
+    config_param :enable_ruby, :bool, default: false
+    desc 'Use original value type.'
+    config_param :auto_typecast, :bool, default: false # false for lower version compatibility
+
+    def configure(conf)
+      super
+
+      map = {}
+      # <record></record> directive
+      conf.elements.select { |element| element.name == 'record' }.each do |element|
+        element.each_pair do |k, v|
+          element.has_key?(k) # to suppress unread configuration warning
+          map[k] = parse_value(v)
+        end
+      end
+
+      if @remove_keys
+        @remove_keys = @remove_keys.split(',')
+      end
+
+      if @keep_keys
+        raise Fluent::ConfigError, "`renew_record` must be true to use `keep_keys`" unless @renew_record
+        @keep_keys = @keep_keys.split(',')
+      end
+
+      placeholder_expander_params = {
+        log: log,
+        auto_typecast: @auto_typecast,
+      }
+      @placeholder_expander =
+        if @enable_ruby
+          # require utilities which would be used in ruby placeholders
+          require 'pathname'
+          require 'uri'
+          require 'cgi'
+          RubyPlaceholderExpander.new(placeholder_expander_params)
+        else
+          PlaceholderExpander.new(placeholder_expander_params)
+        end
+      @map = @placeholder_expander.preprocess_map(map)
+
+      @hostname = Socket.gethostname
+    end
+
+    def filter_stream(tag, es)
+      new_es = Fluent::MultiEventStream.new
+      tag_parts = tag.split('.')
+      tag_prefix = tag_prefix(tag_parts)
+      tag_suffix = tag_suffix(tag_parts)
+      placeholder_values = {
+        'tag'        => tag,
+        'tag_parts'  => tag_parts,
+        'tag_prefix' => tag_prefix,
+        'tag_suffix' => tag_suffix,
+        'hostname'   => @hostname,
+      }
+      last_record = nil
+      es.each do |time, record|
+        last_record = record # for debug log
+        placeholder_values.merge!({
+          'time'     => @placeholder_expander.time_value(time),
+          'record'   => record,
+        })
+        new_record = reform(record, placeholder_values)
+        if @renew_time_key && new_record.has_key?(@renew_time_key)
+          time = Fluent::EventTime.from_time(Time.at(new_record[@renew_time_key].to_f))
+        end
+        new_es.add(time, new_record)
+      end
+      new_es
+    rescue => e
+      log.warn "failed to reform records", error: e
+      log.warn_backtrace
+      log.debug "map:#{@map} record:#{last_record} placeholder_values:#{placeholder_values}"
+    end
+
+    private
+
+    def parse_value(value_str)
+      if value_str.start_with?('{', '[')
+        JSON.parse(value_str)
+      else
+        value_str
+      end
+    rescue => e
+      log.warn "failed to parse #{value_str} as json. Assuming #{value_str} is a string", error: e
+      value_str # emit as string
+    end
+
+    def reform(record, placeholder_values)
+      placeholders = @placeholder_expander.prepare_placeholders(placeholder_values)
+
+      new_record = @renew_record ? {} : record.dup
+      @keep_keys.each {|k| new_record[k] = record[k]} if @keep_keys and @renew_record
+      new_record.merge!(expand_placeholders(@map, placeholders))
+      @remove_keys.each {|k| new_record.delete(k) } if @remove_keys
+
+      new_record
+    end
+
+    def expand_placeholders(value, placeholders)
+      if value.is_a?(String)
+        new_value = @placeholder_expander.expand(value, placeholders)
+      elsif value.is_a?(Hash)
+        new_value = {}
+        value.each_pair do |k, v|
+          new_key = @placeholder_expander.expand(k, placeholders, true)
+          new_value[new_key] = expand_placeholders(v, placeholders)
+        end
+      elsif value.is_a?(Array)
+        new_value = []
+        value.each_with_index do |v, i|
+          new_value[i] = expand_placeholders(v, placeholders)
+        end
+      else
+        new_value = value
+      end
+      new_value
+    end
+
+    def tag_prefix(tag_parts)
+      return [] if tag_parts.empty?
+      tag_prefix = [tag_parts.first]
+      1.upto(tag_parts.size-1).each do |i|
+        tag_prefix[i] = "#{tag_prefix[i-1]}.#{tag_parts[i]}"
+      end
+      tag_prefix
+    end
+
+    def tag_suffix(tag_parts)
+      return [] if tag_parts.empty?
+      rev_tag_parts = tag_parts.reverse
+      rev_tag_suffix = [rev_tag_parts.first]
+      1.upto(tag_parts.size-1).each do |i|
+        rev_tag_suffix[i] = "#{rev_tag_parts[i]}.#{rev_tag_suffix[i-1]}"
+      end
+      rev_tag_suffix.reverse!
+    end
+
+    # THIS CLASS MUST BE THREAD-SAFE
+    class PlaceholderExpander
+      attr_reader :placeholders, :log
+
+      def initialize(params)
+        @log = params[:log]
+        @auto_typecast = params[:auto_typecast]
+      end
+
+      def time_value(time)
+        Time.at(time).to_s
+      end
+
+      def preprocess_map(value, force_stringify = false)
+        value
+      end
+
+      def prepare_placeholders(placeholder_values)
+        placeholders = {}
+
+        placeholder_values.each do |key, value|
+          if value.kind_of?(Array) # tag_parts, etc
+            size = value.size
+            value.each_with_index do |v, idx|
+              placeholders.store("${#{key}[#{idx}]}", v)
+              placeholders.store("${#{key}[#{idx-size}]}", v) # support [-1]
+            end
+          elsif value.kind_of?(Hash) # record, etc
+            value.each do |k, v|
+              unless placeholder_values.has_key?(k) # prevent overwriting reserved keys such as tag
+                placeholders.store("${#{k}}", v) # foo
+              end
+              placeholders.store(%Q[${#{key}["#{k}"]}], v) # record["foo"]
+            end
+          else # string, interger, float, and others?
+            placeholders.store("${#{key}}", value)
+          end
+        end
+
+        placeholders
+      end
+
+      # Expand string with placeholders
+      #
+      # @param [String] str
+      # @param [Boolean] force_stringify the value must be string, used for hash key
+      def expand(str, placeholders, force_stringify = false)
+        if @auto_typecast and !force_stringify
+          single_placeholder_matched = str.match(/\A(\${[^}]+}|__[A-Z_]+__)\z/)
+          if single_placeholder_matched
+            log_if_unknown_placeholder($1, placeholders)
+            return placeholders[single_placeholder_matched[1]]
+          end
+        end
+        str.gsub(/(\${[^}]+}|__[A-Z_]+__)/) {
+          log_if_unknown_placeholder($1, placeholders)
+          placeholders[$1]
+        }
+      end
+
+      private
+
+      def log_if_unknown_placeholder(placeholder, placeholders)
+        unless placeholders.include?(placeholder)
+          log.warn "unknown placeholder `#{placeholder}` found"
+        end
+      end
+    end
+
+    # THIS CLASS MUST BE THREAD-SAFE
+    class RubyPlaceholderExpander
+      attr_reader :log
+
+      def initialize(params)
+        @log = params[:log]
+        @auto_typecast = params[:auto_typecast]
+        @cleanroom_expander = CleanroomExpander.new
+      end
+
+      def time_value(time)
+        Time.at(time)
+      end
+
+      # Preprocess record map to convert into ruby string expansion
+      #
+      # @param [Hash|String|Array] value record map config
+      # @param [Boolean] force_stringify the value must be string, used for hash key
+      def preprocess_map(value, force_stringify = false)
+        new_value = nil
+        if value.is_a?(String)
+          if @auto_typecast and !force_stringify
+            num_placeholders = value.scan('${').size
+            if num_placeholders == 1 and value.start_with?('${') && value.end_with?('}')
+              new_value = value[2..-2] # ${..} => ..
+            end
+          end
+          unless new_value
+            new_value = "%Q[#{value.gsub('${', '#{')}]" # xx${..}xx => %Q[xx#{..}xx]
+          end
+        elsif value.is_a?(Hash)
+          new_value = {}
+          value.each_pair do |k, v|
+            new_value[preprocess_map(k, true)] = preprocess_map(v)
+          end
+        elsif value.is_a?(Array)
+          new_value = []
+          value.each_with_index do |v, i|
+            new_value[i] = preprocess_map(v)
+          end
+        else
+          new_value = value
+        end
+        new_value
+      end
+
+      def prepare_placeholders(placeholder_values)
+        placeholder_values
+      end
+
+      # Expand string with placeholders
+      #
+      # @param [String] str
+      def expand(str, placeholders, force_stringify = false)
+        @cleanroom_expander.expand(
+          str,
+          placeholders['tag'],
+          placeholders['time'],
+          placeholders['record'],
+          placeholders['tag_parts'],
+          placeholders['tag_prefix'],
+          placeholders['tag_suffix'],
+          placeholders['hostname'],
+        )
+      rescue => e
+        log.warn "failed to expand `#{str}`", error: e
+        log.warn_backtrace
+        nil
+      end
+
+      class CleanroomExpander
+        def expand(__str_to_eval__, tag, time, record, tag_parts, tag_prefix, tag_suffix, hostname)
+          tags = tag_parts # for old version compatibility
+          _ = tags # to suppress "unused variable" warning for tags
+          Thread.current[:record_transformer_record] = record # for old version compatibility
+          instance_eval(__str_to_eval__)
+        end
+
+        # for old version compatibility
+        def method_missing(name)
+          key = name.to_s
+          record = Thread.current[:record_transformer_record]
+          if record.has_key?(key)
+            record[key]
+          else
+            raise NameError, "undefined local variable or method `#{key}'"
+          end
+        end
+
+        (Object.instance_methods).each do |m|
+          undef_method m unless m.to_s =~ /^__|respond_to_missing\?|object_id|public_methods|instance_eval|method_missing|define_singleton_method|respond_to\?|new_ostruct_member/
+        end
+      end
+    end
+  end
+end