chef-apply 0.4.12 → 0.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6838824639553486d507ce912e1346c743de3dc13d93c75930ba87392bd3750b
-  data.tar.gz: 1866addf7d4356516b5afd94a21e59de43c32c2fef117a71bec883950ded266f
+  metadata.gz: 40458ce08a16fb6db8c58202ac973c791d653be6b32700a493779ba1ff540dd2
+  data.tar.gz: 68a27c1c83e4009fb29b2fc355091f52bb23f25ea3465069e278982db67b353f
 SHA512:
-  metadata.gz: 36712f4c00946b09a9d20b1c859c02041213453baf7d6404f3b3dc064eb8f40267fce2267f614477016535fc4de88a1f4ca882cec8b365a91e932719a888438e
-  data.tar.gz: 30b001fcf8643a2bd8aaed14798162721f26c0a9b1959f74ac56bdbe4035b4c6017244a6750397a6bb1f232938ab4947e408567d4a3a58fb2209ba9c9939704c
+  metadata.gz: da9d028ca6b0033430f5c8740a1f6c6317eff7331e59ad48d0e198f2fca2f905cb3ea9fa482d0c4366003028bcc5e301cc0c994adfba621ed487637a7348b50a
+  data.tar.gz: aab2c0073c5e20a56045b750044964d336b84da4d2e36085c2efc13386a24d7631d9c8fc2e75a2018189cb694f0adb3779225b5ebab70b892dfaac508e2af632

data/chef-apply.gemspec

@@ -54,7 +54,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "tty-spinner" # Pretty output for status updates in the CLI
   spec.add_dependency "chef", ">= 15.0" # Needed to load cookbooks
   spec.add_dependency "chef-cli", ">= 1.0.3 " # Policyfile
-  spec.add_dependency "chef-telemetry", "<= 0.1.10" # telemetry, updates required to pull in later versions
+  spec.add_dependency "chef-telemetry", ">= 1.0.2"
   spec.add_dependency "license-acceptance", "~> 1.0", ">= 1.0.11"
 
   spec.add_development_dependency "bundler"

data/lib/chef_apply/action/base.rb

@@ -15,7 +15,7 @@
 # limitations under the License.
 #
 
-require "chef_apply/telemeter"
+require "chef/telemeter"
 require "chef_apply/error"
 
 module ChefApply

data/lib/chef_apply/cli.rb

@@ -65,22 +65,20 @@ module ChefApply
 
     def run
       # Perform a timing and capture of the run. Individual methods and actions may perform
-      # nested Telemeter.timed_*_capture or Telemeter.capture calls in their operation, and
+      # nested Chef::Telemeter.timed_*_capture or Chef::Telemeter.capture calls in their operation, and
       # they will be captured in the same telemetry session.
-      # NOTE: We're not currently sending arguments to telemetry because we have not implemented
-      #       pre-parsing of arguments to eliminate potentially sensitive data such as
-      #       passwords in host name, or in ad-hoc converge properties.
-      Telemeter.timed_run_capture([:redacted]) do
+
+      Chef::Telemeter.timed_run_capture([:redacted]) do
         begin
           perform_run
         rescue Exception => e
           @rc = handle_run_error(e)
         end
       end
-    rescue => e
+    rescue => e # can occur if exception thrown in error handling
       @rc = handle_run_error(e)
     ensure
-      Telemeter.commit
+      Chef::Telemeter.commit
       exit @rc
     end
 

data/lib/chef_apply/startup.rb

@@ -17,7 +17,7 @@
 require "chef_apply/config"
 require "chef_apply/text"
 require "chef_apply/ui/terminal"
-require "chef_apply/telemeter/sender"
+require "chef_apply/telemeter"
 require "chef/log"
 require "chef/config"
 module ChefApply
@@ -130,7 +130,14 @@ module ChefApply
     end
 
     def start_telemeter_upload
-      ChefApply::Telemeter::Sender.start_upload_thread
+      cfg = {
+        enabled: Config.telemetry[:enabled],
+        dev: Config.telemetry[:dev_mode],
+        payload_dir: Config.telemetry_path,
+        installation_identifier_file: Config.telemetry_installation_identifier_file,
+        session_file: Config.telemetry_session_file,
+      }
+      Chef::Telemeter.setup(cfg)
     end
 
     def setup_workstation_user_directories

data/lib/chef_apply/telemeter.rb

@@ -1,5 +1,6 @@
 #
-# Copyright:: Copyright (c) 2018 Chef Software Inc.
+# Copyright:: Copyright (c) 2018-2019 Chef Software Inc.
+# Author:: Marc A. Paradise <marc.paradise@gmail.com>
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,48 +14,14 @@
 # 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 "benchmark"
-require "forwardable"
-require "singleton"
-require "json"
-require "digest/sha1"
-require "securerandom"
-require "chef_apply/version"
-require "chef_apply/config"
-require "yaml"
 
+require "chef/telemeter"
+# Monkey patch the telemetry lib to respect our config.toml
+# entry for telemetry.
+require "chef_apply/telemeter/patch"
 module ChefApply
-
-  # This definites the Telemeter interface. Implementation thoughts for
-  # when we unstub it:
-  # - let's track the call sequence; most of our calls will be nested inside
-  # a main 'timed_capture', and it would be good to see ordering within nested calls.
   class Telemeter
-    include Singleton
-    DEFAULT_INSTALLATION_GUID = "00000000-0000-0000-0000-000000000000".freeze
-
-    class << self
-      extend Forwardable
-      def_delegators :instance, :timed_capture, :capture, :commit, :timed_action_capture, :timed_run_capture
-      def_delegators :instance, :pending_event_count, :last_event, :enabled?
-      def_delegators :instance, :make_event_payload
-    end
-
-    attr_reader :events_to_send, :run_timestamp
-
-    def enabled?
-      require "telemetry/decision"
-      ChefApply::Config.telemetry.enable && !Telemetry::Decision.env_opt_out?
-    end
-
-    def initialize
-      @events_to_send = []
-      @run_timestamp =  Time.now.utc.strftime("%FT%TZ")
-    end
-
-    def timed_action_capture(action, &block)
+    def self.timed_action_capture(action, &block)
       # Note: we do not directly capture hostname for privacy concerns, but
       # using a sha1 digest will allow us to anonymously see
       # unique hosts to derive number of hosts affected by a command
@@ -67,96 +34,7 @@ module ChefApply
         target_data[:hostname_sha1] = Digest::SHA1.hexdigest(target.hostname.downcase)
         target_data[:transport_type] = target.transport_type
       end
-      timed_capture(:action, { action: action.name, target: target_data }, &block)
-    end
-
-    def timed_run_capture(arguments, &block)
-      timed_capture(:run, arguments: arguments, &block)
-    end
-
-    def capture(name, data = {})
-      # Adding it to the head of the list will ensure that the
-      # sequence of events is preserved when we send the final payload
-      payload = make_event_payload(name, data)
-      @events_to_send.unshift payload
-    end
-
-    def timed_capture(name, data = {})
-      time = Benchmark.measure { yield }
-      data[:duration] = time.real
-      capture(name, data)
-    end
-
-    def commit
-      if enabled?
-        session = convert_events_to_session
-        write_session(session)
-      end
-      @events_to_send = []
+      Chef::Telemeter.timed_capture(:action, { action: action.name, target: target_data }, &block)
     end
-
-    def make_event_payload(name, data)
-      {
-        event: name,
-        properties: {
-          installation_id: installation_id,
-          run_timestamp: run_timestamp,
-          host_platform: host_platform,
-          event_data: data,
-        },
-      }
-    end
-
-    def installation_id
-      @installation_id ||=
-        begin
-          File.read(ChefApply::Config.telemetry_installation_identifier_file).chomp
-        rescue
-          ChefApply::Log.info "could not read #{ChefApply::Config.telemetry_installation_identifier_file} - using default id"
-          DEFAULT_INSTALLATION_GUID
-        end
-    end
-
-    # For testing.
-    def pending_event_count
-      @events_to_send.length
-    end
-
-    def last_event
-      @events_to_send.last
-    end
-
-    private
-
-    def host_platform
-      @host_platform ||= case RUBY_PLATFORM
-                         when /mswin|mingw|windows/
-                           "windows"
-                         else
-                           RUBY_PLATFORM.split("-")[1]
-                         end
-    end
-
-    def convert_events_to_session
-      YAML.dump({ "version" => ChefApply::VERSION,
-                  "entries" => @events_to_send })
-    end
-
-    def write_session(session)
-      File.write(next_filename, convert_events_to_session)
-    end
-
-    def next_filename
-      id = 0
-      filename = ""
-      loop do
-        id += 1
-        filename = File.join(ChefApply::Config.telemetry_path,
-          "telemetry-payload-#{id}.yml")
-        break unless File.exist?(filename)
-      end
-      filename
-    end
-
   end
 end

data/lib/chef_apply/telemeter/patch.rb

@@ -24,7 +24,7 @@ class Telemetry
   end
 
   def deliver(data = {})
-    if ChefApply::Telemeter.instance.enabled?
+    if Chef::Telemeter.instance.enabled?
       payload = event.prepare(data)
       client.await.fire(payload)
     end

data/lib/chef_apply/version.rb

@@ -16,5 +16,5 @@
 #
 
 module ChefApply
-  VERSION = "0.4.12".freeze
+  VERSION = "0.4.13".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-apply
 version: !ruby/object:Gem::Version
-  version: 0.4.12
+  version: 0.4.13
 platform: ruby
 authors:
 - Chef Software, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-22 00:00:00.000000000 Z
+date: 2020-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
@@ -182,16 +182,16 @@ dependencies:
   name: chef-telemetry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.10
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.10
+        version: 1.0.2
 - !ruby/object:Gem::Dependency
   name: license-acceptance
   requirement: !ruby/object:Gem::Requirement
@@ -269,7 +269,6 @@ files:
 - lib/chef_apply/target_resolver.rb
 - lib/chef_apply/telemeter.rb
 - lib/chef_apply/telemeter/patch.rb
-- lib/chef_apply/telemeter/sender.rb
 - lib/chef_apply/text.rb
 - lib/chef_apply/text/error_translation.rb
 - lib/chef_apply/text/text_wrapper.rb

data/lib/chef_apply/telemeter/sender.rb

@@ -1,121 +0,0 @@
-#
-# Copyright:: Copyright (c) 2018 Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 "telemetry"
-require "chef_apply/telemeter"
-require "chef_apply/telemeter/patch"
-require "chef_apply/log"
-require "chef_apply/version"
-
-module ChefApply
-  class Telemeter
-    class Sender
-      attr_reader :session_files
-
-      def self.start_upload_thread
-        # Find the files before we spawn the thread - otherwise
-        # we may accidentally pick up the current run's session file if it
-        # finishes before the thread scans for new files
-        session_files = Sender.find_session_files
-        sender = Sender.new(session_files)
-        Thread.new { sender.run }
-      end
-
-      def self.find_session_files
-        ChefApply::Log.info("Looking for telemetry data to submit")
-        session_search = File.join(ChefApply::Config.telemetry_path, "telemetry-payload-*.yml")
-        session_files = Dir.glob(session_search)
-        ChefApply::Log.info("Found #{session_files.length} sessions to submit")
-        session_files
-      end
-
-      def initialize(session_files)
-        @session_files = session_files
-      end
-
-      def run
-        if ChefApply::Telemeter.enabled?
-          ChefApply::Log.info("Telemetry enabled, beginning upload of previous session(s)")
-          # dev mode telemetry gets sent to a different location
-          if ChefApply::Config.telemetry.dev
-            ENV["CHEF_TELEMETRY_ENDPOINT"] ||= "https://telemetry-acceptance.chef.io"
-          end
-          session_files.each { |path| process_session(path) }
-        else
-          # If telemetry is not enabled, just clean up and return. Even though
-          # the telemetry gem will not send if disabled, log output saying that we're submitting
-          # it when it has been disabled can be alarming.
-          ChefApply::Log.info("Telemetry disabled, clearing any existing session captures without sending them.")
-          session_files.each { |path| FileUtils.rm_rf(path) }
-        end
-        FileUtils.rm_rf(ChefApply::Config.telemetry_session_file)
-        ChefApply::Log.info("Terminating, nothing more to do.")
-      rescue => e
-        ChefApply::Log.fatal "Sender thread aborted: '#{e}' failed at  #{e.backtrace[0]}"
-      end
-
-      def process_session(path)
-        ChefApply::Log.info("Processing telemetry entries from #{path}")
-        content = load_and_clear_session(path)
-        submit_session(content)
-      end
-
-      def submit_session(content)
-        # Each file contains the actions taken within a single run of the chef tool.
-        # Each run is one session, so we'll first remove remove the session file
-        # to force creating a new one.
-        FileUtils.rm_rf(ChefApply::Config.telemetry_session_file)
-        # We'll use the version captured in the sesion file
-        entries = content["entries"]
-        cli_version = content["version"]
-        total = entries.length
-        telemetry = Telemetry.new(product: "chef-workstation",
-                                  origin: "command-line",
-                                  product_version: cli_version,
-                                  install_context: "omnibus")
-        total = entries.length
-        entries.each_with_index do |entry, x|
-          submit_entry(telemetry, entry, x + 1, total)
-        end
-      end
-
-      def submit_entry(telemetry, entry, sequence, total)
-        ChefApply::Log.info("Submitting telemetry entry #{sequence}/#{total}: #{entry} ")
-        telemetry.deliver(entry)
-        ChefApply::Log.info("Entry #{sequence}/#{total} submitted.")
-      rescue => e
-        # No error handling in telemetry lib, so at least track the failrue
-        ChefApply::Log.error("Failed to send entry #{sequence}/#{total}: #{e}")
-        ChefApply::Log.error("Backtrace: #{e.backtrace} ")
-      end
-
-      private
-
-      def load_and_clear_session(path)
-        content = File.read(path)
-        # We'll remove it now instead of after we parse or submit it -
-        # if we fail to deliver, we don't want to be stuck resubmitting it if the problem
-        # was due to payload. This is a trade-off - if we get a transient error, the
-        # payload will be lost.
-        # TODO: Improve error handling so we can intelligently decide whether to
-        #       retry a failed load or failed submit.
-        FileUtils.rm_rf(path)
-        YAML.load(content)
-      end
-    end
-  end
-end