fastlane-plugin-bugsee 1.0.2 → 1.1.0

data/lib/fastlane/plugin/bugsee/actions/upload_symbols_to_bugsee.rb

@@ -1,11 +1,46 @@
+require 'fastlane/plugin/bugsee/helper/bugsee_handshake'
+
 module Fastlane
   module Actions
 
+    # Upload iOS dSYM(s) to Bugsee, optionally collecting the
+    # project's CocoaPods/SPM/Carthage dependency graph and the
+    # latest Xcode xcactivitylog-derived build timings in the
+    # same lane action.
+    #
+    # ## Cross-producer handshake
+    #
+    # When the Bugsee iOS SDK's `tools.bundle/BugseeAgent` build
+    # phase is wired into the Xcode project, it runs alongside
+    # fastlane and may already have handled some of these
+    # actions for this build. Before invoking BugseeAgent, this
+    # action reads the handshake manifest (see
+    # `Fastlane::Bugsee::Handshake`) and skips per-action work
+    # that's already been done.
+    #
+    # The handshake is checked for THREE independent actions:
+    #
+    #   - `dsym_upload`     — the primary purpose of this action.
+    #   - `deps_collection` — Podfile/Package.resolved/Cartfile
+    #                         parsing + upload.
+    #   - `timings`         — xcactivitylog parsing + upload.
+    #
+    # When ALL three are handled by another producer for this
+    # build, the action skips invoking BugseeAgent entirely. When
+    # SOME are handled, the relevant `--no-*` flags are passed to
+    # BugseeAgent so only the missing work runs.
+    #
+    # The `:force` ConfigItem skips the handshake check entirely.
+    # Useful for re-uploads / debugging.
     class UploadSymbolsToBugseeAction < Action
+
+      BUGSEE_AGENT_PATH = File.expand_path(
+        File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..', 'BugseeAgent'))
+
       def self.run(params)
         app_token = params[:app_token]
         host = params[:host] || "https://api.bugsee.com"
-        agent_path = params[:agent_path] || Dir["./**/BugseeAgent"].first
+        agent_path = params[:agent_path] || BUGSEE_AGENT_PATH
         build_dir = params[:build_dir] || "./"
 
         UI.user_error!("Please provide an app token using app_token:") unless app_token
@@ -26,26 +61,70 @@ module Fastlane
 
         dsym_paths.each do |path|
           print(path)
-          UI.user_error!("dSYM does not exist at path: #{path}") unless File.exists?(path)
+          UI.user_error!("dSYM does not exist at path: #{path}") unless File.exist?(path)
         end
 
-        if dsym_paths.length > 0
-          # Got here from download dsyms
-          command = []
-          command << agent_path.shellescape
-          command << "-e #{host}"
-          command << "-v #{version}" if version
-          command << "-b #{build}" if build
-          command << "-d #{build_dir}"
-          command << "-m #{maps}" if symbol_maps
-          command << "-x -l #{app_token}"
-          command += dsym_paths
-          begin
-            Actions.sh(command.join(" "), log: false)
-          rescue => ex
-            UI.error ex.to_s # it fails, however we don't want to fail everything just for this
+        # ──────────────────────────────────────────────────────
+        # Cross-producer handshake
+        # ──────────────────────────────────────────────────────
+        skip_dsym    = false
+        skip_deps    = false
+        skip_timings = false
+        unless params[:force]
+          manifest = Fastlane::Bugsee::Handshake.find_manifest(
+            search_root: Dir.pwd,
+            version_name: version,
+            version_code: build,
+          )
+          skip_dsym    = Fastlane::Bugsee::Handshake.handled_by_other?(manifest, 'dsym_upload')
+          skip_deps    = Fastlane::Bugsee::Handshake.handled_by_other?(manifest, 'deps_collection')
+          skip_timings = Fastlane::Bugsee::Handshake.handled_by_other?(manifest, 'timings')
+
+          [['dsym_upload',     skip_dsym],
+           ['deps_collection', skip_deps],
+           ['timings',         skip_timings]].each do |action_name, handled|
+            next unless handled
+            UI.important(Fastlane::Bugsee::Handshake.skip_message(manifest, action_name))
           end
         end
+
+        # Strip dSYM paths when the handshake says they're already
+        # handled — sending them along would make BugseeAgent
+        # re-upload them since it interprets positional args as
+        # dSYMs to push.
+        effective_dsyms = skip_dsym ? [] : dsym_paths
+
+        # When there's nothing for BugseeAgent to do at all,
+        # short-circuit before constructing the command.
+        if effective_dsyms.empty? && skip_deps && skip_timings
+          UI.message("Bugsee: nothing to do — every action this lane would have run is already handled by another Bugsee producer for this build")
+          return
+        end
+
+        # If we have NO dSYMs (either none provided OR all
+        # handled) AND deps/timings have work to do, the BugseeAgent
+        # invocation has to be non-dSYM. The agent's main() runs
+        # the deps + timings pipeline unconditionally when
+        # collect_deps is enabled and is told it's not dealing
+        # with dSYMs — passing zero positional args + the
+        # "external" -x flag is the existing shape for that.
+        command = []
+        command << agent_path.shellescape
+        command << "-e #{host}"
+        command << "-v #{version}" if version
+        command << "-b #{build}" if build
+        command << "-d #{build_dir}"
+        command << "-m #{symbol_maps}" if symbol_maps
+        command << "--no-deps" if skip_deps
+        command << "--no-timings" if skip_timings
+        command << "-x -l #{app_token}"
+        command += effective_dsyms
+
+        begin
+          Actions.sh(command.join(" "), log: false)
+        rescue => ex
+          UI.error ex.to_s # it fails, however we don't want to fail everything just for this
+        end
       end
 
 
@@ -55,7 +134,7 @@ module Fastlane
       #####################################################
 
       def self.description
-        
+        "Upload iOS dSYM(s) to Bugsee for crash symbolication. Also collects dependencies + build timings when not already handled by the Bugsee iOS SDK's tools.bundle/BugseeAgent build phase."
       end
 
       def self.details
@@ -107,7 +186,13 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :build_dir,
                                         env_name: "TARGET_BUILD_DIR",
                                         description: "Target build directory",
-                                        optional: true)
+                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "BUGSEE_FORCE",
+                                       description: "Skip the cross-producer handshake check and run every action this lane was configured for, even if the Bugsee iOS SDK BugseeAgent build phase already handled some of them",
+                                       is_string: false,
+                                       default_value: false,
+                                       optional: true)
         ]
       end
 

data/lib/fastlane/plugin/bugsee/helper/bugsee_handshake.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Fastlane
+  module Bugsee
+    # Cross-producer build-action handshake.
+    #
+    # When more than one Bugsee producer can run on a build —
+    # typically the Bugsee Android Gradle plugin OR the Bugsee iOS
+    # SDK's `tools.bundle/BugseeAgent` build phase running ALONGSIDE
+    # this fastlane plugin — we want only ONE producer to handle
+    # each action (mapping upload, dSYM upload, deps collection,
+    # build timings, etc.). Otherwise the same payload reaches the
+    # server twice; the server dedupes by hash so it's not
+    # *broken*, but the lane log gets noisy and the customer pays
+    # for redundant bandwidth.
+    #
+    # Each producer that runs writes a small JSON manifest
+    # declaring which actions it handled for THIS build. The
+    # fastlane plugin reads the most recent matching manifest
+    # before each action and skips work the other producer already
+    # did.
+    #
+    # ## Manifest locations
+    #
+    # - **Bugsee Android Gradle plugin** writes
+    #   `<project>/**/build/intermediates/bugsee/<variant>/build-actions.json`
+    #   from its existing variant tasks (same parent dir as
+    #   `build-id.txt`).
+    # - **Bugsee iOS SDK `tools.bundle/BugseeAgent`** writes
+    #   `<srcroot>/build/bugsee/build-actions.json` from its
+    #   post-build Xcode build phase.
+    #
+    # Both formats share the JSON shape below.
+    #
+    # ## Manifest schema (version 1)
+    #
+    #     {
+    #       "schema_version":   1,
+    #       "producer":         "bugsee-android-gradle-plugin"
+    #                           | "bugsee-ios-sdk-tools-bundle",
+    #       "producer_version": "1.2.3",
+    #       "build_id":         "<BUILD_UUID>",
+    #       "produced_at_ms":   1700000000000,
+    #       "version_name":     "1.2.3",
+    #       "version_code":     "42",
+    #       "actions": {
+    #         "mapping_upload":   true | false,
+    #         "dsym_upload":      true | false,
+    #         "deps_collection":  true | false,
+    #         "timings":          true | false,
+    #         "size_analysis":    true | false,
+    #         "artifact_upload":  true | false
+    #       }
+    #     }
+    #
+    # A `true` value means the named producer ran that action for
+    # this build (whether it succeeded or failed — retrying isn't
+    # fastlane's concern). A `false` or absent value means the
+    # producer was either not configured to handle it or skipped
+    # for this variant. Unknown keys are reserved for forward
+    # compatibility; readers must ignore them.
+    #
+    # ## Staleness window
+    #
+    # A manifest is considered valid only when its `produced_at_ms`
+    # is within {STALENESS_WINDOW_S} seconds of `Time.now`. A stale
+    # manifest from last week's build is treated as absent; fastlane
+    # does the work itself.
+    #
+    # ## Build-identity match
+    #
+    # If the action passes explicit `:version` / `:build`
+    # ConfigItems, those are checked against the manifest's
+    # `version_name` / `version_code`. A mismatch indicates the
+    # manifest is from a different build (developer's previous
+    # archive, CI's previous run, etc.) and is treated as absent.
+    # When the action doesn't pass them, build-identity matching
+    # is skipped and the manifest is honored as long as it's not
+    # stale.
+    #
+    # ## Override
+    #
+    # Every action that uses this helper takes a `:force` ConfigItem
+    # that short-circuits the handshake check. Useful for one-off
+    # re-uploads, debugging, or cases where the user wants fastlane
+    # to do the work regardless of what the other producer claims.
+    module Handshake
+      # Seconds — manifests older than this are treated as absent.
+      # A normal CI run is rare to last more than an hour; a local
+      # dev rerun the next morning genuinely is a different build.
+      STALENESS_WINDOW_S = 60 * 60
+
+      # The canonical action keys the manifest's `actions` block
+      # uses. Producers SHOULD emit only these — unknown keys are
+      # ignored by readers but may be reserved for future features.
+      ACTION_KEYS = %w[
+        mapping_upload
+        dsym_upload
+        deps_collection
+        timings
+        size_analysis
+        artifact_upload
+      ].freeze
+
+      # Filesystem glob patterns for locating manifests. The list
+      # is ordered so that a project laid out for both platforms
+      # at once (e.g. a cross-platform fastlane lane) picks the
+      # most-likely-relevant manifest first.
+      MANIFEST_GLOBS = [
+        # Android Gradle plugin output. The `**/` covers multi-
+        # module projects where the `app/` module nests below a
+        # top-level checkout. The intermediates dir is per-variant
+        # so a project shipping multiple variants will produce
+        # multiple manifests; the staleness + identity check
+        # narrows to the right one.
+        "**/build/intermediates/bugsee/*/build-actions.json",
+        # iOS SDK BugseeAgent output. Single file per project — no
+        # variant slot since iOS targets multiplex through one
+        # build phase.
+        "**/build/bugsee/build-actions.json",
+      ].freeze
+
+      # Locate the manifest most likely to describe THIS build.
+      #
+      # @param search_root [String, nil] directory to search under.
+      #   Defaults to current working directory (most fastlane
+      #   lanes cd to the project root before invoking actions).
+      # @param version_name [String, nil] expected android:versionName
+      #   / iOS CFBundleShortVersionString. When given, the manifest
+      #   must match — used to reject stale manifests from a
+      #   previous build at a different version.
+      # @param version_code [String, Integer, nil] expected
+      #   android:versionCode / iOS CFBundleVersion. Same role.
+      # @param now [Time] for tests — production callers omit it.
+      # @return [Hash, nil] the parsed manifest, or `nil` when no
+      #   valid manifest was found.
+      def self.find_manifest(search_root: Dir.pwd,
+                              version_name: nil,
+                              version_code: nil,
+                              now: Time.now)
+        candidates = MANIFEST_GLOBS.flat_map do |glob|
+          Dir.glob(File.join(search_root, glob))
+        end
+        # Sort newest-first by file mtime; then validity-check.
+        # First valid wins.
+        candidates
+          .sort_by { |p| -File.mtime(p).to_f }
+          .each do |path|
+          parsed = safe_parse(path)
+          next unless parsed
+          next unless valid_for_build?(
+            parsed,
+            version_name: version_name,
+            version_code: version_code,
+            now: now,
+          )
+          return parsed
+        end
+        nil
+      end
+
+      # Per-action skip check.
+      #
+      # @param manifest [Hash, nil] the manifest returned by
+      #   {find_manifest}, or `nil` when none was found.
+      # @param action [String] one of {ACTION_KEYS}.
+      # @return [Boolean] true when ANOTHER producer ran this
+      #   action and fastlane should skip; false otherwise
+      #   (manifest absent, action not listed, action listed false).
+      def self.handled_by_other?(manifest, action)
+        return false if manifest.nil?
+        actions = manifest['actions']
+        return false unless actions.is_a?(Hash)
+        actions[action] == true
+      end
+
+      # Convenience: when {handled_by_other?} is true, build a
+      # log line the action can surface so the user understands
+      # why fastlane is skipping. Returns nil otherwise.
+      def self.skip_message(manifest, action)
+        return nil unless handled_by_other?(manifest, action)
+        producer = manifest['producer'] || 'another Bugsee producer'
+        version = manifest['producer_version']
+        version_str = version ? " (#{version})" : ''
+        "Bugsee: skipping #{action} — already handled by #{producer}#{version_str} for this build"
+      end
+
+      # @api private
+      # Parse + structurally validate a manifest file. Returns the
+      # parsed Hash on success, nil on any error. Errors are
+      # SILENT — a malformed manifest must not break the fastlane
+      # lane.
+      def self.safe_parse(path)
+        return nil unless File.file?(path)
+        raw = File.read(path)
+        return nil if raw.nil? || raw.empty?
+        parsed = JSON.parse(raw)
+        return nil unless parsed.is_a?(Hash)
+        return nil unless parsed['schema_version'] == 1
+        parsed
+      rescue JSON::ParserError, Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      # @api private
+      # Apply the staleness window + build-identity match.
+      def self.valid_for_build?(manifest, version_name:, version_code:, now:)
+        produced_at_ms = manifest['produced_at_ms']
+        return false unless produced_at_ms.is_a?(Numeric)
+        age_s = now.to_f - (produced_at_ms.to_f / 1000.0)
+        # Negative age (manifest from the future — clock skew or
+        # tampered file) is rejected. Excess positive age too.
+        return false if age_s < 0
+        return false if age_s > STALENESS_WINDOW_S
+
+        if version_name && !version_name.to_s.empty?
+          return false unless manifest['version_name'].to_s == version_name.to_s
+        end
+        if version_code && !version_code.to_s.empty?
+          return false unless manifest['version_code'].to_s == version_code.to_s
+        end
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/bugsee/helper/bugsee_uuid.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Fastlane
+  module Bugsee
+    # Cross-language `UUID.nameUUIDFromBytes` equivalent.
+    #
+    # The Bugsee Android SDK (Java) computes synthesized BUILD_UUIDs
+    # via {@code java.util.UUID.nameUUIDFromBytes(bytes)}. Per RFC
+    # 4122 / the Java spec, that's MD5 over the input bytes with two
+    # bit twiddles:
+    #
+    #   - byte 6, upper nibble: clear, then set to 0011 (UUID
+    #     version 3 — name-based, MD5)
+    #   - byte 8, upper two bits: clear, then set to 10 (variant
+    #     RFC 4122)
+    #
+    # The Bugsee Rust CLI's `bugsee-cli` replicates the same
+    # primitive for ProGuard-mapping-content-derived UUIDs (the
+    # `bugsee_cli_proguard_uuid_compat` parity is already proven and
+    # locked in). This Ruby implementation closes the loop for the
+    # fastlane plugin's mapping-upload action: when no explicit
+    # `:uuid` is passed and no Gradle-plugin-emitted `build-uuid.txt`
+    # is found, the action synthesizes a UUID Ruby-side from
+    # `(app_token, version_name, version_code)` and uploads the
+    # mapping with that UUID; the SDK (7.0.0-beta13+) computes the
+    # same bytes at runtime via the same primitive and the server
+    # matches.
+    #
+    # This module has ZERO fastlane dependencies — the unit tests can
+    # require it directly without loading the whole fastlane runtime.
+    module Uuid
+      # ASCII Unit Separator (0x1F). Same byte the SDK uses to join
+      # the synthesis inputs (see
+      # `BugseeEnvironment.BUILD_ID_SYNTHESIS_SEPARATOR`). Guaranteed
+      # never to appear in any of the three inputs (app token is
+      # ASCII hex, versionName is dotted, versionCode is digits).
+      SEPARATOR = ""
+
+      # Ruby equivalent of Java's `UUID.nameUUIDFromBytes(bytes)`.
+      # Takes a String (treated as UTF-8 bytes) or a Binary String,
+      # returns the canonical 8-4-4-4-12 lowercase UUID string.
+      #
+      # NOT a cryptographic primitive. MD5 is deprecated for security
+      # uses but the Java spec mandates it for `nameUUIDFromBytes`,
+      # and we MUST stay byte-for-byte compatible with the SDK side.
+      def self.name_uuid_from_bytes(input)
+        # Force UTF-8 encoding before digest so that a future caller
+        # passing an ASCII-8BIT (binary) string doesn't accidentally
+        # round-trip through a different code path. Digest::MD5 sees
+        # bytes either way, but normalizing upstream removes one
+        # category of "why don't these match" puzzles.
+        bytes = input.dup.force_encoding(Encoding::UTF_8).bytes
+        md5 = Digest::MD5.digest(bytes.pack('C*'))
+        raw = md5.bytes
+
+        # UUID version (4 high bits of byte 6) = 3 (name-based, MD5).
+        raw[6] = (raw[6] & 0x0f) | 0x30
+        # UUID variant (2 high bits of byte 8) = RFC 4122 (binary 10).
+        raw[8] = (raw[8] & 0x3f) | 0x80
+
+        hex = raw.map { |b| b.to_s(16).rjust(2, '0') }.join
+        "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+      end
+
+      # Synthesize a BUILD_UUID matching what the Bugsee Android SDK
+      # 7.0.0-beta13+ computes at runtime when neither the asset
+      # channel nor the manifest meta-data channel populated.
+      #
+      # Formula (must stay byte-for-byte aligned with the SDK side —
+      # see {@code BugseeEnvironment.synthesizeBuildIdFromVersion}):
+      #
+      #     name_uuid_from_bytes(
+      #       app_token + 0x1F + version_name + 0x1F + version_code
+      #     )
+      #
+      # @param app_token   [String] the Bugsee application token
+      #                    (mandatory — disambiguates apps within
+      #                    the same Bugsee organisation).
+      # @param version_name [String, nil] android:versionName from
+      #                    the merged manifest. {@code nil}
+      #                    coerces to empty string (matches the
+      #                    SDK side's null-versionName coercion).
+      # @param version_code [Integer, String] android:versionCode.
+      #                    Coerced to base-10 string. The SDK uses
+      #                    {@code getLongVersionCode().toString()};
+      #                    we accept either an Integer or the
+      #                    pre-stringified form so the fastlane
+      #                    ConfigItem can take either.
+      def self.synthesize_build_uuid(app_token, version_name, version_code)
+        raise ArgumentError, "app_token is required" if app_token.nil? || app_token.to_s.empty?
+
+        version_name_str = version_name.nil? ? "" : version_name.to_s
+        version_code_str = version_code.nil? ? "0" : version_code.to_s
+        input = "#{app_token}#{SEPARATOR}#{version_name_str}#{SEPARATOR}#{version_code_str}"
+        name_uuid_from_bytes(input)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/bugsee/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Bugsee
-    VERSION = "1.0.2"
+    VERSION = "1.1.0"
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-bugsee
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Dmitry Fink
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-31 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -94,23 +93,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.0
-description: 
 email: finik@bugsee.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- BugseeAgent
 - LICENSE
 - README.md
 - lib/fastlane/plugin/bugsee.rb
+- lib/fastlane/plugin/bugsee/actions/upload_artifact_to_bugsee.rb
+- lib/fastlane/plugin/bugsee/actions/upload_mapping_to_bugsee.rb
 - lib/fastlane/plugin/bugsee/actions/upload_symbols_to_bugsee.rb
+- lib/fastlane/plugin/bugsee/helper/bugsee_handshake.rb
 - lib/fastlane/plugin/bugsee/helper/bugsee_helper.rb
+- lib/fastlane/plugin/bugsee/helper/bugsee_uuid.rb
 - lib/fastlane/plugin/bugsee/version.rb
 homepage: https://github.com/bugsee/fastlane-plugin-bugsee
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -125,9 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Bugsee symbols uploader
 test_files: []