iOS SDK Integration

dependencies: [
    .package(url: "https://github.com/kubesense-ai/kubesense-ios-sdk.git", from: "1.0.0")
],
targets: [
    .target(
        name: "MyApp",
        dependencies: [
            .product(name: "KubesenseCore", package: "kubesense-ios-sdk"),
            .product(name: "KubesenseRUM", package: "kubesense-ios-sdk"),
            // Add only the modules you use:
            .product(name: "KubesenseLogs", package: "kubesense-ios-sdk"),
            .product(name: "KubesenseCrashReporting", package: "kubesense-ios-sdk"),
        ]
    )
]

platform :ios, '15.0'
use_frameworks!

target 'MyApp' do
  pod 'KubesenseCore', '~> 1.0'
  pod 'KubesenseRUM', '~> 1.0'
  # Add only the modules you use:
  pod 'KubesenseLogs', '~> 1.0'
  pod 'KubesenseCrashReporting', '~> 1.0'
end

import KubesenseCore
import KubesenseRUM

Kubesense.initialize(
    with: Kubesense.Configuration(
        clientToken: "<CLIENT_TOKEN>",
        env: "production",
        service: "my-ios-app",
        // Single intake host for every feature. Host only — no scheme, no path.
        kubesenseRumEndpoint: "<your-collector-host>"
    ),
    trackingConsent: .granted
)

RUM.enable(with: RUM.Configuration(applicationID: "<RUM_APPLICATION_ID>"))

Kubesense.Configuration(
    clientToken: "<CLIENT_TOKEN>",
    env: "production",
    kubesenseRumEndpoint: "<your-collector-host>",
    remoteConfigurationEnabled: false,              // stay on in-code settings only
    remoteConfigurationRefreshPeriod: 6 * 60 * 60   // seconds; the default
)

import KubesenseRUM

RUM.enable(
    with: RUM.Configuration(
        applicationID: "<RUM_APPLICATION_ID>",
        sessionSampleRate: 100,
        uiKitViewsPredicate: DefaultUIKitRUMViewsPredicate(),
        uiKitActionsPredicate: DefaultUIKitRUMActionsPredicate(),
        swiftUIViewsPredicate: DefaultSwiftUIRUMViewsPredicate(),
        swiftUIActionsPredicate: DefaultSwiftUIRUMActionsPredicate(isLegacyDetectionEnabled: true),
        urlSessionTracking: .init(
            firstPartyHostsTracing: .trace(hosts: ["api.example.com"], sampleRate: 20)
        ),
        trackBackgroundEvents: false,
        appHangThreshold: 0.25,
        trackWatchdogTerminations: true
    )
)

struct CheckoutView: View {
    var body: some View {
        Form { /* ... */ }
            .trackRUMView(name: "checkout")
    }
}

Button("Place order") { placeOrder() }
    .trackRUMTapAction(name: "Place order")

let rum = RUMMonitor.shared()
rum.startView(key: "checkout", name: "Checkout")
// ... when the screen goes away:
rum.stopView(key: "checkout")

// Or for a view controller:
rum.startView(viewController: self, name: "Checkout")

RUMMonitor.shared().addAction(type: .tap, name: "Place order")

// Continuous actions, such as a scroll:
RUMMonitor.shared().startAction(type: .scroll, name: "Product list")
RUMMonitor.shared().stopAction(type: .scroll, name: "Product list")

do {
    try placeOrder()
} catch {
    RUMMonitor.shared().addError(error: error, source: .source)
}

RUMMonitor.shared().addError(message: "Cart is empty", source: .source)

let rum = RUMMonitor.shared()

// Time from the start of the current view:
rum.addTiming(name: "first_item_visible")

// On all following events, or on the current view only:
rum.addAttribute(forKey: "plan", value: "pro")
rum.addViewAttribute(forKey: "cart_items", value: 3)

// Multi-step flows and whether they succeed:
rum.startFeatureOperation(name: "checkout", operationKey: nil, attributes: [:])
rum.succeedFeatureOperation(name: "checkout", operationKey: nil, attributes: [:])

class APISessionDelegate: NSObject, URLSessionDataDelegate {}

URLSessionInstrumentation.enableDurationBreakdown(
    with: .init(delegateClass: APISessionDelegate.self)
)

let session = URLSession(
    configuration: .default,
    delegate: APISessionDelegate(),
    delegateQueue: nil
)

import KubesenseLogs

Logs.enable()

let logger = Logger.create(
    with: Logger.Configuration(
        name: "checkout",
        networkInfoEnabled: true,
        remoteLogThreshold: .info,  // lower levels stay on the device
        consoleLogFormat: .short    // also print to the Xcode console
    )
)

logger.info("Checkout started")
logger.warn("Slow payment provider")
logger.error("Payment failed", attributes: ["reason": "card_declined"])

logger.addAttribute(forKey: "cart_id", value: "c-123")  // on every log of this logger
logger.addTag(withKey: "team", value: "payments")

import KubesenseTrace

Trace.enable(
    with: Trace.Configuration(
        urlSessionTracking: .init(
            firstPartyHostsTracing: .trace(hosts: ["api.example.com"])
        ),
        networkInfoEnabled: true
    )
)

let span = Tracer.shared().startSpan(operationName: "checkout")
span.setTag(key: "cart.items", value: 3)
// ... work ...
span.finish()

import OpenTelemetryApi

OpenTelemetry.registerTracerProvider(tracerProvider: OTelTracerProvider())

let tracer = OpenTelemetry.instance.tracerProvider.get(
    instrumentationName: "checkout",
    instrumentationVersion: nil
)
let span = tracer.spanBuilder(spanName: "place-order").startSpan()
// ... work ...
span.end()

import KubesenseSessionReplay

SessionReplay.enable(
    with: SessionReplay.Configuration(
        replaySampleRate: 20,                       // % of RUM sessions that get a replay
        textAndInputPrivacyLevel: .maskSensitiveInputs,
        imagePrivacyLevel: .maskNonBundledOnly,
        touchPrivacyLevel: .hide,
        startRecordingImmediately: true,
        featureFlags: [.swiftui: true]              // record SwiftUI views; off by default
    )
)

myView.kubesense.sessionReplayPrivacyOverrides.textAndInputPrivacy = .maskAll
myView.kubesense.sessionReplayPrivacyOverrides.hide = true

import KubesenseCrashReporting

CrashReporting.enable()

import KubesenseWebViewTracking

WebViewTracking.enable(webView: webView, hosts: ["shop.example.com"])

// When the web view is no longer used:
WebViewTracking.disable(webView: webView)

import KubesenseFlags

Flags.enable()  // after Kubesense.initialize and RUM.enable

let flags = FlagsClient.create()
flags.setEvaluationContext(
    FlagsEvaluationContext(
        targetingKey: "user-123",
        attributes: ["plan": .string("pro")]
    )
) { result in
    // Flags are ready (or kept their defaults if loading failed).
}

let enabled = flags.getBooleanValue(key: "checkout.enabled", defaultValue: false)

import KubesenseProfiling

Profiling.enable(
    with: Profiling.Configuration(
        applicationLaunchSampleRate: 5,  // % of app launches profiled (default 5)
        continuousSampleRate: 5          // % of RUM sessions profiled continuously (default 5)
    )
)

Kubesense.setUserInfo(id: user.id, name: user.displayName)
Kubesense.setAccountInfo(id: user.accountID)  // optional: the user's company or account

// On sign-out:
Kubesense.clearUserInfo()
Kubesense.clearAccountInfo()

Kubesense.set(trackingConsent: .granted)  // or .notGranted