fastlane 2.62.0.beta.20171016010004 → 2.62.0.beta.20171017010003

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e48c62acc810d151573862aff11a7c34322cd3b2
-  data.tar.gz: 5545f680d045794bb9b749febff528085f748533
+  metadata.gz: f14604abb941543613b3505e11bf099dccccf4ab
+  data.tar.gz: f62ef3b052d856ec84948d52521321455fedb5be
 SHA512:
-  metadata.gz: 6199c80457f0b54f09cc8a86527525ae0f5ffb1ecd375521e04cc2951e21ae116d1dfb1778aaedec59f95c3ec3c4e696371491f77757ce7bcbb6015cfd2ee724
-  data.tar.gz: 5b2b29177b098219e07f06d10c05605ac3d5237ae471b25cf2d353cca1c381f7a1db1240ce958750c42570b9569792b4260838ef64ce723883f050918b6c8914
+  metadata.gz: 03f1513c1a01cc9a51aeb3642907bc93c868f8e1764cee102046f1b4dee88489e6a86ea0e076d8203794d916bc612a31b2198ddd5ffca9a0d88710df27742481
+  data.tar.gz: 0318818369814716e8b1f4403276ce4b4d7673e49a2b6ae2aaddda43638ddf89a35d5a61cab5b1656e6e118ebbe1d9e3a8c320d2e830eee39eff0141f4118a00

data/fastlane/lib/fastlane/fast_file.rb

@@ -150,10 +150,6 @@ module Fastlane
     # @!group Other things
     #####################################################
 
-    def collector
-      runner.collector
-    end
-
     # Is the given key a platform block or a lane?
     def is_platform_block?(key)
       UI.crash!('No key given') unless key
@@ -217,8 +213,13 @@ module Fastlane
       actions_path = File.join(File.expand_path("..", path), 'actions')
       Fastlane::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
 
-      collector.did_launch_action(:import)
-      parse(File.read(path), path)
+      action_launched('import')
+
+      return_value = parse(File.read(path), path)
+
+      action_completed('import', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+
+      return return_value
     end
 
     # @param url [String] The git URL to clone the repository from
@@ -230,7 +231,7 @@ module Fastlane
       Actions.execute_action('import_from_git') do
         require 'tmpdir'
 
-        collector.did_launch_action(:import_from_git)
+        action_launched('import_from_git')
 
         # Checkout the repo
         repo_name = url.split("/").last
@@ -258,7 +259,11 @@ module Fastlane
             # We don't care about a failure here, as local actions are optional
           end
 
-          import(File.join(clone_folder, path))
+          return_value = import(File.join(clone_folder, path))
+
+          action_completed('import_from_git', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+
+          return return_value
         end
       end
     end
@@ -272,21 +277,36 @@ module Fastlane
       # Overwrite this, since there is already a 'say' method defined in the Ruby standard library
       value ||= yield
       Actions.execute_action('say') do
-        collector.did_launch_action(:say)
-        Fastlane::Actions::SayAction.run([value])
+        action_launched('say')
+        return_value = Fastlane::Actions::SayAction.run([value])
+        action_completed('say', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+        return return_value
       end
     end
 
     def puts(value)
       # Overwrite this, since there is already a 'puts' method defined in the Ruby standard library
       value ||= yield if block_given?
-      collector.did_launch_action(:puts)
-      Fastlane::Actions::PutsAction.run([value])
+
+      action_launched('puts')
+      return_value = Fastlane::Actions::PutsAction.run([value])
+      action_completed('puts', status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+      return return_value
     end
 
     def test(params = {})
       # Overwrite this, since there is already a 'test' method defined in the Ruby standard library
       self.runner.try_switch_to_lane(:test, [params])
     end
+
+    def action_launched(action_name)
+      action_launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(action_name, args: ARGV)
+      FastlaneCore.session.action_launched(launch_context: action_launch_context)
+    end
+
+    def action_completed(action_name, status: nil)
+      completion_context = FastlaneCore::ActionCompletionContext.context_for_action_name(action_name, args: ARGV, status: status)
+      FastlaneCore.session.action_completed(completion_context: completion_context)
+    end
   end
 end

data/fastlane/lib/fastlane/lane_manager.rb

@@ -38,6 +38,8 @@ module Fastlane
 
       platform, lane = choose_lane(ff, platform) unless lane
 
+      FastlaneCore.session.is_fastfile = true
+
       # xcodeproj has a bug in certain versions that causes it to change directories
       # and not return to the original working directory
       # https://github.com/CocoaPods/Xcodeproj/issues/426
@@ -76,8 +78,6 @@ module Fastlane
 
     # All the finishing up that needs to be done
     def self.finish_fastlane(ff, duration, error)
-      ff.runner.did_finish
-
       # Finished with all the lanes
       Fastlane::JUnitGenerator.generate(Fastlane::Actions.executed_actions)
       print_table(Fastlane::Actions.executed_actions)

data/fastlane/lib/fastlane/runner.rb

@@ -197,7 +197,10 @@ module Fastlane
 
         # Actually switch lane now
         self.current_lane = new_lane
-        collector.did_launch_action(:lane_switch)
+
+        launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name('lane_switch', args: ARGV)
+        FastlaneCore.session.action_launched(launch_context: launch_context)
+
         result = block.call(parameters.first || {}) # to always pass a hash
         self.current_lane = original_lane
 
@@ -218,11 +221,12 @@ module Fastlane
         custom_dir ||= ".."
       end
 
-      collector.did_launch_action(method_sym)
-
       verify_supported_os(method_sym, class_ref)
 
       begin
+        launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(method_sym.to_s, args: ARGV)
+        FastlaneCore.session.action_launched(launch_context: launch_context)
+
         Dir.chdir(custom_dir) do # go up from the fastlane folder, to the project folder
           # If another action is calling this action, we shouldn't show it in the summary
           # (see https://github.com/fastlane/fastlane/issues/4546)
@@ -249,7 +253,11 @@ module Fastlane
             end
 
             class_ref.runner = self # needed to call another action form an action
-            class_ref.run(arguments)
+            return_value = class_ref.run(arguments)
+
+            action_completed(method_sym.to_s, status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+
+            return return_value
           end
         end
       rescue Interrupt => e
@@ -258,17 +266,25 @@ module Fastlane
         raise e
       rescue FastlaneCore::Interface::FastlaneError => e # user_error!
         FastlaneCore::CrashReporter.report_crash(exception: e)
-        collector.did_raise_error(method_sym) if e.fastlane_should_report_metrics?
+        action_completed(method_sym.to_s, status: FastlaneCore::ActionCompletionStatus::USER_ERROR, exception: e)
         raise e
       rescue Exception => e # rubocop:disable Lint/RescueException
         # high chance this is actually FastlaneCore::Interface::FastlaneCrash, but can be anything else
         # Catches all exceptions, since some plugins might use system exits to get out
         FastlaneCore::CrashReporter.report_crash(exception: e)
-        collector.did_crash(method_sym) if e.fastlane_should_report_metrics?
+
+        action_completed(method_sym.to_s, status: FastlaneCore::ActionCompletionStatus::FAILED, exception: e)
         raise e
       end
     end
 
+    def action_completed(action_name, status: nil, exception: nil)
+      if exception.nil? || exception.fastlane_should_report_metrics?
+        action_completion_context = FastlaneCore::ActionCompletionContext.context_for_action_name(action_name, args: ARGV, status: status)
+        FastlaneCore.session.action_completed(completion_context: action_completion_context)
+      end
+    end
+
     def execute_flow_block(block, current_platform, lane, parameters)
       # Call the platform specific block and default back to the general one
       block[current_platform].call(lane, parameters) if block[current_platform] && current_platform
@@ -287,15 +303,6 @@ module Fastlane
       end
     end
 
-    def collector
-      @collector ||= ActionCollector.new
-    end
-
-    # Fastfile was finished executing
-    def did_finish
-      collector.did_finish
-    end
-
     # Called internally to setup the runner object
     #
 

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.62.0.beta.20171016010004'.freeze
+  VERSION = '2.62.0.beta.20171017010003'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
 end

data/fastlane_core/lib/fastlane_core.rb

@@ -40,6 +40,11 @@ require 'fastlane_core/ui/errors/fastlane_crash'
 require 'fastlane_core/ui/errors/fastlane_shell_error'
 require 'fastlane_core/ui/errors/fastlane_common_error'
 require 'fastlane_core/test_parser'
+require 'fastlane_core/analytics/action_completion_context'
+require 'fastlane_core/analytics/action_launch_context'
+require 'fastlane_core/analytics/analytics_event_builder'
+require 'fastlane_core/analytics/analytics_ingester_client'
+require 'fastlane_core/analytics/analytics_session'
 
 # Third Party code
 require 'colored'
@@ -51,6 +56,19 @@ require 'fastlane_core/ui/fastlane_runner' # monkey patch
 module FastlaneCore
   ROOT = Pathname.new(File.expand_path('../..', __FILE__))
 
+  # Session is used to report usage metrics.
+  # If you opt out, we will not send anything.
+  # You can confirm this by observing how we use the environment variable: FASTLANE_OPT_OUT_USAGE
+  # Specifically, in AnalyticsSession.finalize_session
+  # Learn more at https://github.com/fastlane/fastlane#metrics
+  def self.session
+    @session ||= AnalyticsSession.new
+  end
+
+  def self.reset_session
+    @session = nil
+  end
+
   # A directory that's being used to user-wide fastlane configs
   # This directory is also used for the bundled fastlane
   # Since we don't want to access FastlaneCore from spaceship

data/fastlane_core/lib/fastlane_core/analytics/action_completion_context.rb

@@ -0,0 +1,29 @@
+module FastlaneCore
+  class ActionCompletionStatus
+    SUCCESS = 'success'
+    FAILED = 'failed' # fastlane crashes unrelated to user_error!
+    USER_ERROR = 'user_error' # Anytime a user_error! is triggered
+    INTERRUPTED = 'interrupted'
+  end
+
+  class ActionCompletionContext
+    attr_accessor :p_hash
+    attr_accessor :action_name
+    attr_accessor :status
+
+    def initialize(p_hash: nil, action_name: nil, status: nil)
+      @p_hash = p_hash
+      @action_name = action_name
+      @status = status
+    end
+
+    def self.context_for_action_name(action_name, args: nil, status: nil)
+      app_id_guesser = FastlaneCore::AppIdentifierGuesser.new(args: args)
+      return self.new(
+        action_name: action_name,
+        p_hash: app_id_guesser.p_hash,
+        status: status
+      )
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/action_launch_context.rb

@@ -0,0 +1,34 @@
+require 'fastlane_core/helper'
+
+module FastlaneCore
+  class ActionLaunchContext
+    UNKNOWN_P_HASH = 'unknown'
+
+    attr_accessor :action_name
+    attr_accessor :p_hash
+    attr_accessor :platform
+
+    def initialize(action_name: nil, p_hash: UNKNOWN_P_HASH, platform: nil)
+      @action_name = action_name
+      @p_hash = p_hash
+      @platform = platform
+    end
+
+    def self.context_for_action_name(action_name, args: nil)
+      app_id_guesser = FastlaneCore::AppIdentifierGuesser.new(args: args)
+      return self.new(
+        action_name: action_name,
+        p_hash: app_id_guesser.p_hash,
+        platform: app_id_guesser.platform
+      )
+    end
+
+    def build_tool_version
+      if platform == :android
+        return 'android'
+      else
+        return "Xcode #{Helper.xcode_version}"
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/analytics_event_builder.rb

@@ -0,0 +1,50 @@
+module FastlaneCore
+  class AnalyticsEventBuilder
+    attr_accessor :base_hash
+    attr_accessor :action_name
+
+    def initialize(oauth_app_name: nil, p_hash: nil, session_id: nil, action_name: nil, timestamp_millis: (Time.now.to_f * 1000).to_i)
+      @action_name = action_name
+      @base_hash = {
+        event_source: {
+          oauth_app_name: oauth_app_name,
+          product: 'fastlane'
+        },
+        actor: {
+          name: p_hash,
+          detail: session_id
+        },
+        millis_since_epoch: timestamp_millis,
+        version: 1
+      }
+    end
+
+    def launched_event(primary_target_hash: nil, secondary_target_hash: nil)
+      return new_event(
+        stage: 'launched',
+        primary_target_hash: primary_target_hash,
+        secondary_target_hash: secondary_target_hash
+      )
+    end
+
+    def completed_event(primary_target_hash: nil, secondary_target_hash: nil)
+      return new_event(
+        stage: 'completed',
+        primary_target_hash: primary_target_hash,
+        secondary_target_hash: secondary_target_hash
+      )
+    end
+
+    def new_event(stage: nil, primary_target_hash: nil, secondary_target_hash: nil)
+      raise 'Need at least a primary_target_hash' if primary_target_hash.nil?
+      event = base_hash.dup
+      event[:action] = {
+          name: stage,
+          detail: action_name
+      }
+      event[:primary_target] = primary_target_hash
+      event[:secondary_target] = secondary_target_hash unless secondary_target_hash.nil?
+      return event
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/analytics_ingester_client.rb

@@ -0,0 +1,45 @@
+module FastlaneCore
+  class AnalyticsIngesterClient
+    def post_events(events)
+      unless Helper.test?
+        fork do
+          send_request(json: { analytics: events }.to_json)
+        end
+      end
+      return true
+    end
+
+    def send_request(json: nil, retries: 2)
+      post_request(body: json)
+    rescue
+      retries -= 1
+      retry if retries >= 0
+    end
+
+    def post_request(body: nil)
+      if ENV['METRICS_DEBUG']
+        write_json(body)
+      end
+      url = ENV["FASTLANE_METRICS_URL"] || "https://fastlane-metrics.fabric.io"
+
+      require 'faraday'
+      connection = Faraday.new(url) do |conn|
+        conn.adapter Faraday.default_adapter
+        if ENV['METRICS_DEBUG']
+          conn.proxy = "https://127.0.0.1:8888"
+          conn.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+      connection.post do |req|
+        req.url '/public'
+        req.headers['Content-Type'] = 'application/json'
+        req.body = body
+      end
+    end
+
+    # This method is only for debugging purposes
+    def write_json(body)
+      File.write("#{ENV['HOME']}/Desktop/mock_analytics-#{Time.now.to_i}.json", body)
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/analytics_session.rb

@@ -0,0 +1,201 @@
+require 'fastlane_core/analytics/analytics_ingester_client'
+
+module FastlaneCore
+  class AnalyticsSession
+    attr_accessor :session_id
+    attr_accessor :client
+    attr_accessor :events
+    attr_accessor :fastfile_id
+    attr_accessor :is_fastfile
+    alias fastfile? is_fastfile
+
+    # make this a method so that we can override it in monkey patches
+    def oauth_app_name
+      return 'fastlane_v2'
+    end
+
+    def initialize(analytics_ingester_client: AnalyticsIngesterClient.new)
+      require 'securerandom'
+      @session_id = SecureRandom.uuid
+      @client = analytics_ingester_client
+      @events = []
+      @is_fastfile = false
+    end
+
+    def backfill_p_hashes(p_hash: nil)
+      return if p_hash.nil? || p_hash == ActionLaunchContext::UNKNOWN_P_HASH || @events.count == 0
+      @events.reverse_each do |event|
+        # event[:actor][:name] is the field in which we store the p_hash
+        # to be sent to analytics ingester.
+        # If they are nil, we want to fill them in until we reach
+        # an event that already has a p_hash.
+        if event[:actor][:name].nil? || event[:actor][:name] == ActionLaunchContext::UNKNOWN_P_HASH
+          event[:actor][:name] = p_hash
+        else
+          break
+        end
+      end
+    end
+
+    def action_launched(launch_context: nil)
+      backfill_p_hashes(p_hash: launch_context.p_hash)
+
+      builder = AnalyticsEventBuilder.new(
+        oauth_app_name: oauth_app_name,
+        p_hash: launch_context.p_hash,
+        session_id: session_id,
+        action_name: launch_context.action_name
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'fastlane_version',
+          detail: fastlane_version
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'install_method',
+          detail: install_method
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'operating_system',
+          detail: operating_system
+        },
+        secondary_target_hash: {
+          name: 'version',
+          detail: operating_system_version
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'build_tool_version',
+          detail: launch_context.build_tool_version
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'ci',
+          detail: ci?.to_s
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'fastfile',
+          detail: fastfile?.to_s
+        },
+        secondary_target_hash: {
+          name: 'fastfile_id',
+          detail: fastfile_id.to_s
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'platform',
+          detail: launch_context.platform.to_s
+        }
+      )
+
+      @events << builder.launched_event(
+        primary_target_hash: {
+          name: 'ruby_version',
+          detail: ruby_version
+        }
+      )
+    end
+
+    def is_fastfile=(value)
+      if value
+        # If true, update all of the events to reflect
+        # that the execution is running within a Fastfile context.
+        # We don't want to update if this is false because once we
+        # detect a true value, that is the one to be trusted
+        @events.reverse_each do |event|
+          event[:primary_target][:name] == 'fastfile' ? event[:primary_target][:detail] = value.to_s : next
+        end
+      end
+      @is_fastfile = value
+    end
+
+    def action_completed(completion_context: nil)
+      backfill_p_hashes(p_hash: completion_context.p_hash)
+
+      builder = AnalyticsEventBuilder.new(
+        oauth_app_name: oauth_app_name,
+        p_hash: completion_context.p_hash,
+        session_id: session_id,
+        action_name: completion_context.action_name
+      )
+
+      @events << builder.completed_event(
+        primary_target_hash: {
+          name: 'status',
+          detail: completion_context.status
+        }
+      )
+    end
+
+    def finalize_session
+      # If our users want to opt out of usage metrics, don't post the events.
+      # Learn more at https://github.com/fastlane/fastlane#metrics
+      return if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
+
+      client.post_events(@events)
+    end
+
+    def fastlane_version
+      return Fastlane::VERSION
+    end
+
+    def ruby_version
+      patch_level = RUBY_PATCHLEVEL == 0 ? nil : "p#{RUBY_PATCHLEVEL}"
+      return "#{RUBY_VERSION}#{patch_level}"
+    end
+
+    def operating_system
+      return "macOS" if RUBY_PLATFORM.downcase.include?("darwin")
+      return "Windows" if RUBY_PLATFORM.downcase.include?("mswin")
+      return "Linux" if RUBY_PLATFORM.downcase.include?("linux")
+      return "Unknown"
+    end
+
+    def install_method
+      if Helper.rubygems?
+        return 'gem'
+      elsif Helper.bundler?
+        return 'bundler'
+      elsif Helper.mac_app?
+        return 'mac_app'
+      elsif Helper.contained_fastlane?
+        return 'standalone'
+      elsif Helper.homebrew?
+        return 'homebrew'
+      else
+        return 'unknown'
+      end
+    end
+
+    def ci?
+      return Helper.is_ci?
+    end
+
+    def operating_system_version
+      os = self.operating_system
+      case os
+      when "macOS"
+        return `SW_VERS -productVersion`.strip
+      else
+        # Need to test in Windows and Linux... not sure this is enough
+        return Gem::Platform.local.version
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/app_identifier_guesser.rb

@@ -0,0 +1,64 @@
+require 'fastlane_core/android_package_name_guesser'
+require 'fastlane_core/ios_app_identifier_guesser'
+
+module FastlaneCore
+  class AppIdentifierGuesser
+    attr_accessor :args
+    attr_accessor :gem_name
+    attr_accessor :platform
+    attr_accessor :p_hash
+    attr_accessor :app_id
+
+    def initialize(args: nil, gem_name: 'fastlane')
+      @args = args
+      @gem_name = gem_name
+
+      @app_id = android_app_identifier(args, gem_name)
+      @platform = nil # since have a state in-between runs
+      if @app_id
+        @platform = :android
+      else
+        @app_id = ios_app_identifier(args)
+        @platform = :ios if @app_id
+      end
+
+      @p_hash = generate_p_hash(@app_id)
+    end
+
+    # To not count the same projects multiple time for the number of launches
+    # Learn more at https://github.com/fastlane/fastlane#metrics
+    # Use the `FASTLANE_OPT_OUT_USAGE` variable to opt out
+    # The resulting value is e.g. ce12f8371df11ef6097a83bdf2303e4357d6f5040acc4f76019489fa5deeae0d
+    def generate_p_hash(app_id)
+      unless !FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE") && !app_id.nil?
+        return nil
+      end
+
+      require 'credentials_manager'
+      return Digest::SHA256.hexdigest("p#{app_id}fastlan3_SAlt") # hashed + salted the bundle identifier
+    rescue
+      return nil # we don't want this method to cause a crash
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    def ios_app_identifier(args)
+      return FastlaneCore::IOSAppIdentifierGuesser.guess_app_identifier(args)
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    # supply and screengrab use different param names and env variable patterns so we have to special case here
+    # example:
+    #   fastlane supply --skip_upload_screenshots -a beta -p com.test.app should return com.test.app
+    #   screengrab -a com.test.app should return com.test.app
+    def android_app_identifier(args, gem_name)
+      app_identifier = FastlaneCore::AndroidPackageNameGuesser.guess_package_name(gem_name, args)
+
+      # Add Android prefix to prevent collisions if there is an iOS app with the same identifier
+      app_identifier ? "android_project_#{app_identifier}" : nil
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/fastlane_runner.rb

@@ -60,8 +60,13 @@ module Commander
           FastlaneCore::UI.user_error!("fastlane requires a minimum version of Xcode #{Fastlane::MINIMUM_XCODE_RELEASE}, please upgrade and make sure to use `sudo xcode-select -s /Applications/Xcode.app`")
         end
 
-        collector.did_launch_action(@program[:name])
-        run_active_command
+        action_launch_context = FastlaneCore::ActionLaunchContext.context_for_action_name(@program[:name], args: ARGV)
+        FastlaneCore.session.action_launched(launch_context: action_launch_context)
+
+        return_value = run_active_command
+
+        action_completed(@program[:name], status: FastlaneCore::ActionCompletionStatus::SUCCESS)
+        return return_value
       rescue InvalidCommandError => e
         # calling `abort` makes it likely that tests stop without failing, so
         # we'll disable that during tests.
@@ -76,6 +81,7 @@ module Commander
         if FastlaneCore::Globals.verbose?
           raise e
         else
+          action_completed(@program[:name], status: FastlaneCore::ActionCompletionStatus::INTERRUPTED, exception: e)
           puts "\nCancelled... use --verbose to show the stack trace"
         end
       rescue \
@@ -116,12 +122,15 @@ module Commander
       rescue => e # high chance this is actually FastlaneCore::Interface::FastlaneCrash, but can be anything else
         rescue_unknown_error(e)
       ensure
-        collector.did_finish
+        FastlaneCore.session.finalize_session
       end
     end
 
-    def collector
-      @collector ||= FastlaneCore::ToolCollector.new
+    def action_completed(action_name, status: nil, exception: nil)
+      if exception.nil? || exception.fastlane_should_report_metrics?
+        action_completion_context = FastlaneCore::ActionCompletionContext.context_for_action_name(action_name, args: ARGV, status: status)
+        FastlaneCore.session.action_completed(completion_context: action_completion_context)
+      end
     end
 
     def rescue_file_error(e)
@@ -145,12 +154,15 @@ module Commander
 
     def rescue_unknown_error(e)
       FastlaneCore::CrashReporter.report_crash(exception: e)
-      collector.did_crash(@program[:name]) if e.fastlane_should_report_metrics?
+
+      action_completed(@program[:name], status: FastlaneCore::ActionCompletionStatus::FAILED, exception: e)
+
       handle_unknown_error!(e)
     end
 
     def rescue_fastlane_error(e)
-      collector.did_raise_error(@program[:name]) if e.fastlane_should_report_metrics?
+      action_completed(@program[:name], status: FastlaneCore::ActionCompletionStatus::USER_ERROR, exception: e)
+
       show_github_issues(e.message) if e.show_github_issues
       FastlaneCore::CrashReporter.report_crash(exception: e)
       display_user_error!(e, e.message)
@@ -247,6 +259,7 @@ module Commander
         reraise_formatted!(e, message)
       else
         # without stack trace
+        action_completed(@program[:name], status: FastlaneCore::ActionCompletionStatus::USER_ERROR, exception: e)
         abort "\n[!] #{message}".red
       end
     end

data/fastlane_core/lib/fastlane_core/update_checker/update_checker.rb

@@ -2,8 +2,7 @@ require 'excon'
 require 'digest'
 
 require 'fastlane_core/update_checker/changelog'
-require 'fastlane_core/ios_app_identifier_guesser'
-require 'fastlane_core/android_package_name_guesser'
+require 'fastlane_core/analytics/app_identifier_guesser'
 
 module FastlaneCore
   # Verifies, the user runs the latest version of this gem
@@ -121,64 +120,11 @@ module FastlaneCore
       "https://rubygems.org/api/v1/gems/#{gem_name}.json"
     end
 
-    # (optional) Returns the app identifier for the current tool
-    def self.ios_app_identifier(args)
-      return FastlaneCore::IOSAppIdentifierGuesser.guess_app_identifier(args)
-    rescue
-      nil # we don't want this method to cause a crash
-    end
-
-    # (optional) Returns the app identifier for the current tool
-    # supply and screengrab use different param names and env variable patterns so we have to special case here
-    # example:
-    #   fastlane supply --skip_upload_screenshots -a beta -p com.test.app should return com.test.app
-    #   screengrab -a com.test.app should return com.test.app
-    def self.android_app_identifier(args, gem_name)
-      app_identifier = FastlaneCore::AndroidPackageNameGuesser.guess_package_name(gem_name, args)
-
-      # Add Android prefix to prevent collisions if there is an iOS app with the same identifier
-      app_identifier ? "android_project_#{app_identifier}" : nil
-    rescue
-      nil # we don't want this method to cause a crash
-    end
-
-    # To not count the same projects multiple time for the number of launches
-    # Learn more at https://github.com/fastlane/fastlane#metrics
-    # Use the `FASTLANE_OPT_OUT_USAGE` variable to opt out
-    # The resulting value is e.g. ce12f8371df11ef6097a83bdf2303e4357d6f5040acc4f76019489fa5deeae0d
-    def self.p_hash(args, gem_name)
-      return nil if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
-      require 'credentials_manager'
-
-      app_identifier = app_id(args, gem_name)
-
-      if app_identifier
-        return Digest::SHA256.hexdigest("p#{app_identifier}fastlan3_SAlt") # hashed + salted the bundle identifier
-      end
-
-      return nil
-    rescue
-      return nil
-    end
-
-    def self.app_id(args, gem_name)
-      # check if this is an android project first because some of the same params exist for iOS and Android tools
-      app_identifier = android_app_identifier(args, gem_name)
-      @platform = nil # since have a state in-between runs
-      if app_identifier
-        @platform = :android
-      else
-        app_identifier = ios_app_identifier(args)
-        @platform = :ios if app_identifier
-      end
-      return app_identifier
-    end
-
     def self.send_launch_analytic_events_for(gem_name)
       return if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
-
       ci = Helper.is_ci?.to_s
-      project_hash = p_hash(ARGV, gem_name)
+      app_id_guesser = FastlaneCore::AppIdentifierGuesser.new(args: ARGV, gem_name: gem_name)
+      project_hash = app_id_guesser.p_hash
       p_hash = project_hash if project_hash
       platform = @platform if @platform # this has to be called after `p_hash`
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane
 version: !ruby/object:Gem::Version
-  version: 2.62.0.beta.20171016010004
+  version: 2.62.0.beta.20171017010003
 platform: ruby
 authors:
 - Felix Krause
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-16 00:00:00.000000000 Z
+date: 2017-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slack-notifier
@@ -1171,6 +1171,12 @@ files:
 - fastlane_core/README.md
 - fastlane_core/lib/assets/XMLTemplate.xml.erb
 - fastlane_core/lib/fastlane_core.rb
+- fastlane_core/lib/fastlane_core/analytics/action_completion_context.rb
+- fastlane_core/lib/fastlane_core/analytics/action_launch_context.rb
+- fastlane_core/lib/fastlane_core/analytics/analytics_event_builder.rb
+- fastlane_core/lib/fastlane_core/analytics/analytics_ingester_client.rb
+- fastlane_core/lib/fastlane_core/analytics/analytics_session.rb
+- fastlane_core/lib/fastlane_core/analytics/app_identifier_guesser.rb
 - fastlane_core/lib/fastlane_core/android_package_name_guesser.rb
 - fastlane_core/lib/fastlane_core/build_watcher.rb
 - fastlane_core/lib/fastlane_core/cert_checker.rb