standard_singpass 0.3.0 → 0.4.0

data/lib/standard_singpass/myinfo/client.rb

@@ -60,32 +60,35 @@ module StandardSingpass
           )
         }
 
-        # Ask Singpass to enforce a minimum assurance level upstream. The same
-        # config attribute also drives downstream validation of the returned
-        # id_token (validate_id_token_acr) — defense in depth. When unset, we
-        # skip both the request parameter and the validator entirely; useful
-        # for sandbox personas that may return non-conformant acr values.
-        # Concrete URN per Singpass: `urn:singpass:authentication:loa:N` (N
-        # is 2 or 3; Singpass never issues below LOA 2). `.to_s.strip` mirrors
-        # the validator so whitespace-only values are treated as unset and any
-        # value sent over the wire is trimmed.
-        min_acr = @minimum_acr.to_s.strip
-        body[:acr_values] = min_acr unless min_acr.empty?
-
-        with_network_wrapper do
-          response = http_connection.post(@par_url) do |req|
-            req.headers["DPoP"] = Security.build_dpop_proof(
-              http_method: "POST",
-              url: T.must(@par_url),
-              key_pair: dpop_key_pair
-            )
-            req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-            req.body = URI.encode_www_form(body)
+        # `acr_values` is deliberately NEVER sent, even when `minimum_acr` is
+        # configured. Singpass rejects it on a MyInfo PAR:
+        #
+        #   PAR failed (HTTP 400) invalid_request —
+        #   "The acr_values parameter can only be used for specific use cases."
+        #
+        # Until 0.3.1 a non-empty `minimum_acr` was forwarded here, which broke
+        # every MyInfo onboarding for any host that set it. `minimum_acr` is
+        # now purely a client-side check of the returned id_token `acr` claim
+        # (see validate_id_token_acr); MyInfo's assurance level itself is
+        # governed by Singpass server-side.
+
+        instrument(:par) do |payload|
+          with_network_wrapper do
+            response = http_connection.post(@par_url) do |req|
+              req.headers["DPoP"] = Security.build_dpop_proof(
+                http_method: "POST",
+                url: T.must(@par_url),
+                key_pair: dpop_key_pair
+              )
+              req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+              req.body = URI.encode_www_form(body)
+            end
+            payload[:status] = response.status
+            handle_par_response(response)
           end
-          handle_par_response(response)
+        rescue Faraday::Error => e
+          raise PARError.new("PAR endpoint unreachable: #{e.class}", transport: true)
         end
-      rescue Faraday::Error => e
-        raise PARError.new("PAR endpoint unreachable: #{e.class}", transport: true)
       end
 
       sig { params(request_uri: String).returns(String) }
@@ -151,20 +154,23 @@ module StandardSingpass
           )
         }
 
-        with_network_wrapper do
-          response = http_connection.post(@token_url) do |req|
-            req.headers["DPoP"] = Security.build_dpop_proof(
-              http_method: "POST",
-              url: T.must(@token_url),
-              key_pair: dpop_key_pair
-            )
-            req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-            req.body = URI.encode_www_form(body)
+        instrument(:token) do |payload|
+          with_network_wrapper do
+            response = http_connection.post(@token_url) do |req|
+              req.headers["DPoP"] = Security.build_dpop_proof(
+                http_method: "POST",
+                url: T.must(@token_url),
+                key_pair: dpop_key_pair
+              )
+              req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+              req.body = URI.encode_www_form(body)
+            end
+            payload[:status] = response.status
+            handle_token_response(response)
           end
-          handle_token_response(response)
+        rescue Faraday::Error => e
+          raise ApiError.new("MyInfo token endpoint unreachable: #{e.class}", transport: true)
         end
-      rescue Faraday::Error => e
-        raise ApiError.new("MyInfo token endpoint unreachable: #{e.class}", transport: true)
       end
 
       sig { params(access_token: String, dpop_key_pair: OpenSSL::PKey::EC).returns(T::Hash[String, T.untyped]) }
@@ -173,24 +179,27 @@ module StandardSingpass
         # is typically a circuit breaker; keeping retries inside means one user
         # attempt counts as one failure against the breaker instead of three,
         # so a single unlucky borrower can't trip a shared circuit on their own.
-        with_network_wrapper do
-          with_userinfo_retries do
-            # The DPoP proof carries a per-request jti/iat, so it is rebuilt on
-            # every attempt — replaying one would be rejected as a duplicate.
-            response = http_connection.get(@userinfo_url) do |req|
-              req.headers["Authorization"] = "DPoP #{access_token}"
-              req.headers["DPoP"] = Security.build_dpop_proof(
-                http_method: "GET",
-                url: T.must(@userinfo_url),
-                key_pair: dpop_key_pair,
-                access_token:
-              )
+        instrument(:userinfo) do |payload|
+          with_network_wrapper do
+            with_userinfo_retries(payload) do
+              # The DPoP proof carries a per-request jti/iat, so it is rebuilt on
+              # every attempt — replaying one would be rejected as a duplicate.
+              response = http_connection.get(@userinfo_url) do |req|
+                req.headers["Authorization"] = "DPoP #{access_token}"
+                req.headers["DPoP"] = Security.build_dpop_proof(
+                  http_method: "GET",
+                  url: T.must(@userinfo_url),
+                  key_pair: dpop_key_pair,
+                  access_token:
+                )
+              end
+              payload[:status] = response.status
+              handle_person_response(response, jwks_url: @userinfo_jwks_url)
             end
-            handle_person_response(response, jwks_url: @userinfo_jwks_url)
           end
+        rescue Faraday::Error => e
+          raise ApiError.new("MyInfo userinfo endpoint unreachable: #{e.class}", transport: true)
         end
-      rescue Faraday::Error => e
-        raise ApiError.new("MyInfo userinfo endpoint unreachable: #{e.class}", transport: true)
       end
 
       sig { params(id_token: T.nilable(String), nonce: T.nilable(String)).returns(T::Hash[String, T.untyped]) }
@@ -220,9 +229,9 @@ module StandardSingpass
 
         decrypted = Security.decrypt_jwe(id_token, private_keys: @encryption_keys)
         Security.validate_jws(decrypted, jwks_url: T.must(@jwks_url))
-      rescue Security::DecryptionError
+      rescue DecryptionError
         raise AuthenticationError, "ID token decryption failed"
-      rescue Security::ValidationError => e
+      rescue SignatureError => e
         # Carry status/transport across the re-raise: a JWKS endpoint that is
         # down produces the same exception here as a genuinely bad signature,
         # and only these attributes tell them apart.
@@ -299,8 +308,9 @@ module StandardSingpass
       # Enforce a minimum Authentication Context Class Reference (`acr`) on the
       # id_token. The floor is configured via `minimum_acr` so staging and
       # production can diverge — staging may tolerate looser values returned by
-      # MyInfo sandbox personas. When the attr is unset or blank, both this
-      # validator and the upstream PAR `acr_values` parameter are skipped.
+      # MyInfo sandbox personas. When the attr is unset or blank, this
+      # validator is skipped. This is the ONLY effect of `minimum_acr` — it is
+      # never sent to Singpass as `acr_values` (see push_authorization_request).
       #
       # Singpass's `acr` URN format is `urn:singpass:authentication:loa:N`
       # where N is 2 or 3 (no LOA 1 path — Singpass's IdP is 2FA by design).
@@ -405,17 +415,26 @@ module StandardSingpass
       # in well under a second, whereas a timed-out attempt has already spent
       # the request budget and retrying it risks turning a slow page into a
       # gateway error. A transport failure therefore propagates on the first hit.
-      sig { params(block: T.proc.returns(T::Hash[String, T.untyped])).returns(T::Hash[String, T.untyped]) }
-      def with_userinfo_retries(&block)
+      #
+      # Each retry emits a `standard_singpass.retry` notification; the
+      # enclosing `standard_singpass.userinfo` payload records `attempts`.
+      sig { params(payload: T::Hash[Symbol, T.untyped], block: T.proc.returns(T::Hash[String, T.untyped])).returns(T::Hash[String, T.untyped]) }
+      def with_userinfo_retries(payload, &block)
         attempt = 0
         begin
           attempt += 1
+          payload[:attempts] = attempt
           block.call
         rescue ApiError => e
           raise unless RETRYABLE_USERINFO_STATUSES.include?(e.status)
           raise if attempt >= USERINFO_MAX_ATTEMPTS
 
-          sleep(userinfo_retry_delay(attempt))
+          delay = userinfo_retry_delay(attempt)
+          ActiveSupport::Notifications.instrument(
+            "standard_singpass.retry",
+            leg: :userinfo, attempt:, status: e.status, error: e.class.name, delay:
+          )
+          sleep(delay)
           retry
         end
       end
@@ -462,15 +481,13 @@ module StandardSingpass
         "(non-JSON body, #{body.bytesize} bytes)"
       end
 
+      # Security raises the public DecryptionError / SignatureError directly
+      # (SignatureError carrying the JWKS response's status / transport?), so
+      # there is nothing to translate on the userinfo leg.
       sig { params(jwe_body: String, jwks_url: T.nilable(String)).returns(T::Hash[String, T.untyped]) }
       def decrypt_and_validate_person(jwe_body, jwks_url:)
         decrypted = Security.decrypt_jwe(jwe_body, private_keys: @encryption_keys)
         Security.validate_jws(decrypted, jwks_url: T.must(jwks_url))
-      rescue Security::DecryptionError => e
-        raise DecryptionError, e.message
-      rescue Security::ValidationError => e
-        # As above — a JWKS-host outage must not be reported as a bad signature.
-        raise SignatureError.new(e.message, status: e.status, transport: e.transport?)
       end
 
       sig { void }
@@ -487,6 +504,48 @@ module StandardSingpass
         end
       end
 
+      # Emits `standard_singpass.<event>` via ActiveSupport::Notifications
+      # around one leg of the flow. The payload is deliberately PII-free:
+      #
+      #   :duration  — wall time in milliseconds (Float)
+      #   :status    — HTTP status of the (last) Singpass response, or nil
+      #   :error     — class name of the error raised, or nil on success
+      #   :transport — true when Singpass was never reached
+      #   :attempts  — (userinfo only) attempts made, including retries
+      #
+      # Never tokens, codes, bodies, URLs, or error messages. The error is
+      # captured inside the instrument block and re-raised outside it so
+      # ActiveSupport does not add its own `:exception` entry (which would
+      # carry the message) to the payload.
+      sig do
+        params(
+          event: Symbol,
+          block: T.proc.params(payload: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+        ).returns(T.untyped)
+      end
+      def instrument(event, &block)
+        payload = T.let({ status: nil, error: nil, transport: false }, T::Hash[Symbol, T.untyped])
+        error = T.let(nil, T.nilable(Exception))
+        result = ActiveSupport::Notifications.instrument("standard_singpass.#{event}", payload) do
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          begin
+            block.call(payload)
+          rescue => e
+            error = e
+            payload[:error] = e.class.name
+            if e.is_a?(Error)
+              payload[:status] ||= e.status
+              payload[:transport] = e.transport?
+            end
+            nil
+          ensure
+            payload[:duration] = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000.0
+          end
+        end
+        raise error if error
+        result
+      end
+
       # Wraps the given block in the configured network_wrapper. Default is
       # the identity wrapper (no resilience). Hosts typically set this to a
       # circuit-breaker lambda. Scoped narrowly to the Faraday network call

data/lib/standard_singpass/myinfo/configuration.rb

@@ -10,11 +10,18 @@
 #   c.client_id          - App ID from Singpass Developer Portal
 #   c.redirect_url       - OAuth callback URL (e.g. https://example.com/singpass/callback)
 #   c.private_jwks_json  - Full JWKS JSON string with private signing + encryption keys
-#                          (keys are identified by "use": "sig" and "use": "enc")
+#                          (keys are identified by "use": "sig" and "use": "enc").
+#                          Parsed lazily, so it can be assigned in any order.
 #
 # Optional attributes:
-#   c.scope                  - Space-separated scopes (defaults to DEFAULT_SCOPE)
-#   c.minimum_acr            - Required Authentication Context Class Reference URN
+#   c.scope                  - Space-separated scopes. Defaults to the minimal
+#                              DEFAULT_SCOPE ("openid uinfin name"); every
+#                              real host should set its own approved list.
+#   c.minimum_acr            - Minimum Authentication Context Class Reference URN
+#                              (e.g. urn:singpass:authentication:loa:3) checked
+#                              client-side against the id_token `acr` claim.
+#                              Never sent to Singpass: `acr_values` on a MyInfo
+#                              PAR is rejected with HTTP 400 invalid_request.
 #   c.network_wrapper        - Lambda wrapping outbound Faraday calls (e.g. circuit breaker)
 #   c.mock_mode              - When true, suppresses missing-key warnings
 #                              (and is refused outright on a production deploy
@@ -29,79 +36,25 @@
 module StandardSingpass
   module Myinfo
     class Configuration
-      # Default MyInfo scope — keep aligned with the Singpass developer-portal
-      # approval list. Entries on separate lines so diffs against the portal's
-      # ordered dump are reviewable line-by-line. Joined into a single
-      # space-delimited string before sending to PAR.
-      DEFAULT_SCOPE = %w[
-        openid
-        aliasname
-        cpfbalances.oa
-        cpfcontributions
-        cpfemployers
-        cpfhousingwithdrawal
-        dob
-        email
-        employment
-        employmentsector
-        hanyupinyinaliasname
-        hanyupinyinname
-        hdbownership.address
-        hdbownership.balanceloanrepayment
-        hdbownership.hdbtype
-        hdbownership.loangranted
-        hdbownership.monthlyloaninstalment
-        hdbownership.noofowners
-        hdbownership.outstandinginstalment
-        hdbownership.outstandingloanbalance
-        hdbtype
-        housingtype
-        marital
-        marriedname
-        mobileno
-        name
-        nationality
-        noa
-        noa-basic
-        noahistory
-        noahistory-basic
-        occupation
-        ownerprivate
-        passexpirydate
-        passstatus
-        passtype
-        race
-        regadd
-        residentialstatus
-        sex
-        uinfin
-        vehicles.effectiveownership
-      ].join(" ").freeze
-
-      # The categories and their lender-underwriting purpose (PDPA §18,
-      # Purpose Limitation):
+      # Default MyInfo scope: the minimal identity set (`openid` plus the
+      # NRIC/FIN and name). Deliberately tiny.
       #
-      #   Identity        — uinfin, name, alias names, dob, sex, race,
-      #                     nationality, residentialstatus → KYC, contracts
-      #   Pass (FIN-only) — passtype, passstatus, passexpirydate,
-      #                     employmentsector → tenure-vs-pass-expiry, eligibility
-      #   Address         — regadd, hdbtype, housingtype → KYC + income proxy
-      #   Contact         — mobileno, email → OTP, mailers
-      #   Family          — marital → soft underwriting signal
-      #   Income          — noa, noa-basic, noahistory, noahistory-basic,
-      #                     cpfcontributions → MAS TDSR input
-      #   Employment      — employment, occupation, cpfemployers
-      #                     → continuity + employer stability
-      #   Assets          — cpfbalances.oa (only OA — MA/SA/RA are ring-fenced
-      #                     and not lender-relevant), ownerprivate
-      #   Liabilities     — cpfhousingwithdrawal, hdbownership.* (8 sub-fields)
-      #                     → TDSR housing component
-      #   Vehicle         — vehicles.effectiveownership (asset/liability hint;
-      #                     full vehicle details deliberately not requested)
+      # Which person attributes to request is a business decision (PDPA §18,
+      # Purpose Limitation) that must match the host's Singpass
+      # developer-portal approval list, so it belongs to the host, not this
+      # gem. Until 0.4.0 this constant was one consuming app's 42-entry
+      # underwriting scope — including `noa`, `noa-basic` and
+      # `noahistory-basic`, which Singpass review later flagged as redundant
+      # collection — and any host that relied on the default silently
+      # requested all of it.
       #
-      # `cpfbalances.oa`, `hdbownership.*`, and `vehicles.effectiveownership`
-      # use FAPI 2.0 sub-attribute scope notation — sharper data minimisation
-      # than parent-keyword grants.
+      # A minimal default rather than a boot-time "scope is required" error:
+      # `openid uinfin name` is a subset of every MyInfo approval, so a host
+      # that forgets to set `scope` gets a working flow that collects the
+      # least data possible, instead of either over-collecting (the old
+      # default) or failing to boot in development and test. Hosts set
+      # `c.scope` explicitly; the install generator does.
+      DEFAULT_SCOPE = "openid uinfin name"
 
       PRODUCTION_ENDPOINTS = {
         authorize_url:     "https://id.singpass.gov.sg/fapi/auth",
@@ -126,7 +79,6 @@ module StandardSingpass
       attr_accessor :authorize_url, :par_url, :token_url, :userinfo_url,
                     :jwks_url, :userinfo_jwks_url, :issuer,
                     :client_id, :redirect_url, :scope,
-                    :signing_key, :signing_kid, :encryption_keys,
                     :minimum_acr, :network_wrapper, :mock_mode, :personas_path
 
       # Optional callable deciding whether the current deploy is real
@@ -144,6 +96,10 @@ module StandardSingpass
         self.environment = :staging
         @scope = DEFAULT_SCOPE
         @encryption_keys = []
+        @signing_key = nil
+        @signing_kid = nil
+        @private_jwks_json = nil
+        @private_jwks_pending = false
         @network_wrapper = ->(&block) { block.call }
         @mock_mode = false
         @production_env_detector = nil
@@ -163,18 +119,77 @@ module StandardSingpass
 
       attr_reader :environment
 
-      # Accepts the raw JWKS JSON string and populates signing_key, signing_kid,
-      # and encryption_keys. Logs and reports issues via Rails.logger / Rails.error
-      # rather than raising — a malformed JWKS silently degrades the Singpass
-      # widget at runtime, but the host should boot regardless.
+      # Stores the raw private JWKS JSON string. Parsing into signing_key,
+      # signing_kid, and encryption_keys is deferred until one of those is
+      # first read (or `resolve_private_jwks!` is called — the engine does so
+      # from `after_initialize`, alongside MockModeGuard, so problems surface
+      # at boot). Until 0.4.0 this setter parsed eagerly, so its warnings
+      # depended on `mock_mode` having been assigned *before* it ("set
+      # last"); deferring makes the configure block order-independent.
+      #
+      # Issues are logged and reported via Rails.logger / Rails.error rather
+      # than raised — a malformed JWKS silently degrades the Singpass widget
+      # at runtime, but the host should boot regardless.
       def private_jwks_json=(jwks_json)
+        @private_jwks_json = jwks_json
+        @private_jwks_pending = true
+      end
+
+      attr_reader :private_jwks_json
+
+      def signing_key
+        resolve_private_jwks!
+        @signing_key
+      end
+
+      def signing_kid
+        resolve_private_jwks!
+        @signing_kid
+      end
+
+      def encryption_keys
+        resolve_private_jwks!
+        @encryption_keys
+      end
+
+      # Direct assignment still works (and wins over an earlier
+      # `private_jwks_json=`): any pending JWKS is resolved first so it can't
+      # later overwrite the explicit value.
+      def signing_key=(value)
+        resolve_private_jwks!
+        @signing_key = value
+      end
+
+      def signing_kid=(value)
+        resolve_private_jwks!
+        @signing_kid = value
+      end
+
+      def encryption_keys=(value)
+        resolve_private_jwks!
+        @encryption_keys = value
+      end
+
+      # Parses the pending private JWKS, if any. Idempotent: a no-op until
+      # `private_jwks_json=` is assigned again. Returns self.
+      def resolve_private_jwks!
+        return self unless @private_jwks_pending
+
+        @private_jwks_pending = false
+        parse_private_jwks(@private_jwks_json)
+        self
+      end
+
+      private
+
+      def parse_private_jwks(jwks_json)
         @encryption_keys = []
         @signing_key = nil
         @signing_kid = nil
 
         if jwks_json.nil? || jwks_json.to_s.strip.empty?
-          return if mock_mode || (defined?(Rails) && Rails.env.test?)
-          Rails.logger.warn("StandardSingpass::Myinfo: private_jwks_json is not set — Singpass flow will fail at first request")
+          return if quiet?
+          log(:warn, "private_jwks_json is not set — Singpass flow will fail at first request")
           return
         end
 
@@ -183,7 +198,7 @@ module StandardSingpass
         keys = jwks["keys"] || []
 
         sig_jwks = keys.select { |k| k.is_a?(Hash) && k["use"] == "sig" }
-        Rails.logger.warn("StandardSingpass::Myinfo: multiple sig keys in private_jwks_json — using first") if sig_jwks.size > 1
+        log(:warn, "multiple sig keys in private_jwks_json — using first") if sig_jwks.size > 1
         sig_jwk = sig_jwks.first
         if sig_jwk
           @signing_kid = sig_jwk["kid"]
@@ -192,8 +207,8 @@ module StandardSingpass
           # confusing in console triage (which is the scenario this method is
           # trying to help with).
           @signing_kid = nil unless @signing_key
-        elsif !mock_mode && !(defined?(Rails) && Rails.env.test?)
-          Rails.logger.error("StandardSingpass::Myinfo: private_jwks_json contains no key with \"use\":\"sig\"")
+        elsif !quiet?
+          log(:error, "private_jwks_json contains no key with \"use\":\"sig\"")
         end
 
         enc_jwks = keys.select { |k| k.is_a?(Hash) && k["use"] == "enc" }
@@ -206,11 +221,11 @@ module StandardSingpass
         # forgot to include enc keys) vs all-rejected (every enc key was
         # public-only or otherwise unloadable). The latter is the trap the
         # rest of this method is built to catch.
-        if @encryption_keys.empty? && !mock_mode && !(defined?(Rails) && Rails.env.test?)
+        if @encryption_keys.empty? && !quiet?
           if enc_jwks.empty?
-            Rails.logger.error("StandardSingpass::Myinfo: private_jwks_json contains no key with \"use\":\"enc\"")
+            log(:error, "private_jwks_json contains no key with \"use\":\"enc\"")
           else
-            Rails.logger.error("StandardSingpass::Myinfo: private_jwks_json has \"use\":\"enc\" keys but none are usable (all public-only or invalid)")
+            log(:error, "private_jwks_json has \"use\":\"enc\" keys but none are usable (all public-only or invalid)")
           end
         end
       rescue JSON::ParserError, TypeError => e
@@ -220,12 +235,31 @@ module StandardSingpass
         # Reported because a malformed private JWKS silently degrades the
         # Singpass widget — the request that finally fails will report, but by
         # then customers have hit the broken page.
-        Rails.logger.error("StandardSingpass::Myinfo: failed to parse private_jwks_json: #{e.class}: #{e.message}")
-        Rails.error.report(e, handled: true, context: { component: "StandardSingpass::Myinfo::Configuration", reason: "parse_private_jwks" }) if defined?(Rails.error)
+        log(:error, "failed to parse private_jwks_json: #{e.class}: #{e.message}")
+        report(e, reason: "parse_private_jwks")
         @encryption_keys = []
       end
 
-      private
+      # Missing-key warnings are noise in mock mode and in the test env.
+      # Read at parse time — i.e. after the whole configure block has run —
+      # so the order of assignments inside the block no longer matters.
+      def quiet?
+        mock_mode || (defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env.test?)
+      end
+
+      # Rails.logger / Rails.error are optional: the gem can be loaded (and a
+      # Configuration built) outside a booted Rails app — tooling, plain Ruby
+      # scripts, or before the logger is assigned.
+      def log(level, message)
+        return unless defined?(::Rails) && ::Rails.respond_to?(:logger)
+        ::Rails.logger&.public_send(level, "StandardSingpass::Myinfo: #{message}")
+      end
+
+      def report(error, reason:, **context)
+        return unless defined?(::Rails) && ::Rails.respond_to?(:error)
+        ::Rails.error.report(error, handled: true, context: { component: "StandardSingpass::Myinfo::Configuration", reason:, **context })
+      end
+
 
       # Converts a JWK to a *private* PEM. Refuses public-only JWKs — the
       # private scalar (`d` for EC) must be present, otherwise signing /
@@ -235,13 +269,13 @@ module StandardSingpass
       def jwk_to_private_pem(jwk_hash, role:)
         kid = jwk_hash["kid"]
         if jwk_hash["d"].blank?
-          Rails.logger.error("StandardSingpass::Myinfo: #{role} JWK #{kid.inspect} is public-only (missing \"d\") — re-export with include_private: true")
+          log(:error, "#{role} JWK #{kid.inspect} is public-only (missing \"d\") — re-export with include_private: true")
           return nil
         end
         JWT::JWK.new(jwk_hash).keypair.to_pem
       rescue => e
-        Rails.logger.error("StandardSingpass::Myinfo: failed to convert #{role} JWK #{kid.inspect}: #{e.class} — #{e.message}")
-        Rails.error.report(e, handled: true, context: { component: "StandardSingpass::Myinfo::Configuration", reason: "jwk_to_private_pem", role:, kid: }) if defined?(Rails.error)
+        log(:error, "failed to convert #{role} JWK #{kid.inspect}: #{e.class} — #{e.message}")
+        report(e, reason: "jwk_to_private_pem", role:, kid:)
         nil
       end
     end