{
  "resource_name": "Api::V1::FacilitiesController#share",
  "service": "cupixworks-api",
  "occurrences": 7,
  "avg_ms": 2998,
  "max_ms": 6821,
  "sample_trace_id": "2403094205503981716"
}

def share
  validate_project_permissions_feature!

  members = repository_instance.share(
    params.slice(*SHARE_REQUEST_PARAMS),
    params[:permission]
  )

  render_api Renderable.new({
    contents: members,
    is_collection: true,
    serializer: MemberSerializer
  })
end

(@users + @groups + already_joined_or_invited_users + invited_users).each do |user_or_group|
  @model.add_permission! user_or_group, permission
  shared_users_and_groups << user_or_group
rescue ActiveRecord::RecordInvalid => e
  raise Cupix::Errors::Entity.new(code: 'ENT10003', reason: e.message)
end

def add_permission!(user_or_group, permission)
  _permission = permissions.find_or_initialize_by(accessor: user_or_group)
  _permission.permission = permission
  _permission.save!

  Permissionable.flush_cached_permissions(user_or_group)
  Permissionable.flush_cached_permissions_by_user(user_or_group, self)

  _permission
end

after_commit do |model|
  model.pub_sub_notifications_manager.publish_notifications(namespace)
  model.pub_sub_notifications_manager.reset_notifications(namespace)
end

def broadcast_event(namespace, event_name, payload = {}, &block)
  event_name = [namespace, event_name].compact.join('.')

  ActiveSupport::Notifications.instrument(event_name, payload) do
    yield if block_given?
  end
end

def _create_subscriptions_by_facility_permission(model)
  return false unless model.accessor_type == ::User.name

  user = model.accessor
  facility_key = model.facility.key

  _create_subscription(user: user, facility_key: facility_key)
end

def _create_subscription(opts = {})
  Cupix::NotificationService.new(user: opts[:user]).subscribe(facility_key: opts[:facility_key])
end

def _create_recipes_for_facility_permission(model)
  return false unless model.accessor_type == ::User.name

  user = model.accessor
  team_id = model.facility.team_id
  facility_key = model.facility.key

  _create_recipes(user: user, team_id: team_id, facility_key: facility_key)
end

def _create_recipes(opts = {})
  %w[
    record_preview_ready
    record_processing_completed
    facility_new_project
  ].each do |recipe_name|
    Cupix::NotificationService.new(user: opts[:user]).create_user_recipe(recipe_name, team_id: opts[:team_id], facility_key: opts[:facility_key])
  end
end

def subscribe(facility_key: nil)
  return if @service_url.nil?

  begin
    response = Cupix::HttpClient.put(
      "#{@service_url}/api/v1/subscriptions",
      {
        model_type: 'Facility',
        model_id: facility_key
      }.to_json,
      {
        content_type: :json,
        'x-cupix-auth': @user.api_token
      }
    )
    # ...
  end
end

service:cupixworks-api @http.url_details.path:"/api/v1/facilities/*/share" @http.status_code:200

Duration breakdown for slowest request (21,026ms):
- DB time: 755ms (3.6%)
- Notification API calls: ~20,254ms (96.4%)
  - 7 subscriptions created
  - 22 recipes created (7 users × 3 + 1 retry)
  - Timestamps span: 09:56:42Z to 09:56:54Z (~12 seconds of sequential API calls)

fields=11 (full share): 30 requests, avg 7,380ms, max 21,026ms
fields=2 (lightweight): 19 requests, avg 1,334ms, max 4,300ms

{
  "message": "recipe created: ...",
  "class": "Cupix::NotificationService",
  "function": "create_user_recipe",
  "recipe_name": "record_preview_ready",
  "facility_key": "..."
}

{
  "message": "subscription of user@example.com on Facility abc123 created",
  "class": "Cupix::NotificationService",
  "function": "subscribe",
  "facility_key": "abc123"
}

avg:trace.rack.request.duration{service:cupixworks-api, resource_name:api::v1::facilitiescontroller#share} by {region}

service:cupixworks-api "Cupix::NotificationService" ("recipe created" OR "subscription of") | stats count by facility_key