Engenharia de Analytics e Telemetria em Mobile: Arquitetura de Eventos sem Impacto de Performance

A Caotização do Tagueamento em Aplicativos em Crescimento

Em muitas organizações de tecnologia, o rastreamento analítico (Analytics e Telemetria) nasce como uma tarefa secundária e desorganizada. À medida que os times de Produto (PO/PM) e Marketing solicitam métricas de conversão e funis de engajamento, desenvolvedores passam a espalhar chamadas diretas a múltiplos SDKs externos (Google Analytics, Firebase, Mixpanel, AppsFlyer) diretamente nos eventos de toque de botões e ciclos de vida de UIViewController.

Essa abordagem ad-hoc gera três problemas graves de engenharia:

• Alto Acoplamento: Telas e regras de negócio ficam repletas de código de instrumentação que nada tem a ver com o domínio do aplicativo;
• Divergência de Schemas: Nomes de eventos e parâmetros digitados manualmente como strings literais (ex: "button_clicked" vs "btn_click") geram inconsistências catastróficas nos relatórios dos times de Dados e Business Intelligence (BI);
• Degradação de Performance e Bateria: Disparar requisições de rede individuais a cada evento drena a bateria do dispositivo móvel e compete com as requisições essenciais do produto.

Modelagem Tipada de Eventos com Enums e Protocolos

A primeira medida para garantir conformidade de dados é banir strings literais soltas e adotar tipagem estrita em Swift:

import Foundation

public protocol AnalyticsEventProtocol {
    var name: String { get }
    var parameters: [String: Any] { get }
}

public enum FinancialAnalyticsEvent: AnalyticsEventProtocol {
    case cardActivated(cardType: String, hasVirtualOption: Bool)
    case transactionInitiated(amount: Double, currency: String)
    case checkoutFailed(errorCode: Int, reason: String)

    public var name: String {
        switch self {
        case .cardActivated: return "financial_card_activated"
        case .transactionInitiated: return "financial_transaction_initiated"
        case .checkoutFailed: return "financial_checkout_failed"
        }
    }

    public var parameters: [String: Any] {
        switch self {
        case let .cardActivated(type, virtual):
            return ["card_type": type, "is_virtual": virtual]
        case let .transactionInitiated(amount, currency):
            return ["transaction_amount": amount, "currency": currency]
        case let .checkoutFailed(code, reason):
            return ["error_code": code, "failure_reason": reason]
        }
    }
}

O Barramento Central de Rastreamento (Analytics Dispatcher)

O despachante central atua como uma fachada única registrada no módulo de infraestrutura. Ele recebe o evento tipado, adiciona automaticamente parâmetros contextuais globais (versão do aplicativo, modelo do dispositivo, idioma e tipo de conexão) e repassa para uma lista de provedores plugáveis:

public protocol AnalyticsProviderProtocol {
    func track(eventName: String, parameters: [String: Any])
}

public final class AnalyticsDispatcher {
    public static let shared = AnalyticsDispatcher()
    private var providers: [AnalyticsProviderProtocol] = []
    private let queue = DispatchQueue(label: "com.analytics.queue", qos: .utility)

    private init() {}

    public func register(provider: AnalyticsProviderProtocol) {
        providers.append(provider)
    }

    public func track(_ event: AnalyticsEventProtocol) {
        queue.async {
            var consolidatedParams = event.parameters
            // Enriquecimento com metadados globais
            consolidatedParams["app_version"] = "2.4.0"
            consolidatedParams["platform"] = "iOS"
            consolidatedParams["timestamp"] = Date().timeIntervalSince1970

            for provider in self.providers {
                provider.track(eventName: event.name, parameters: consolidatedParams)
            }
        }
    }
}

Enfileiramento em Lote (Batching) e Otimização Energética

Em vez de abrir um túnel HTTPS com os servidores de telemetria a cada ação do usuário, o despachante pode enfileirar os eventos em uma base SQLite local ou em memória:

• Os eventos são acumulados em lotes de 20 a 30 itens ou transmitidos em intervalos regulares (a cada 60 segundos);
• Quando o aplicativo é movido para segundo plano (background), um flush emergencial descarrega o buffer pendente;
• Se o dispositivo estiver offline ou em modo de economia de energia, os eventos ficam retidos em disco e são sincronizados assim que a conectividade for restabelecida.

Testando a Telemetria com Confiabilidade sem Dependências Externas

Com esse design desacoplado, testar o tagueamento torna-se tão simples quanto testar qualquer regra de negócio. Durante a execução da suite de testes unitários (XCTest), injetamos um AnalyticsProviderSpy e verificamos assertivamente se a ação do usuário disparou o evento com os parâmetros exatos esperados:

final class AnalyticsSpy: AnalyticsProviderProtocol {
    var loggedEvents: [(name: String, params: [String: Any])] = []

    func track(eventName: String, parameters: [String: Any]) {
        loggedEvents.append((name: eventName, params: parameters))
    }
}

func test_whenUserTapsActivateCard_shouldTrackCorrectEvent() {
    let spy = AnalyticsSpy()
    let sut = CardPresenter(analytics: spy)

    sut.handleCardActivation(type: "Gold", hasVirtual: true)

    XCTAssertEqual(spy.loggedEvents.count, 1)
    XCTAssertEqual(spy.loggedEvents.first?.name, "financial_card_activated")
    XCTAssertEqual(spy.loggedEvents.first?.params["card_type"] as? String, "Gold")
}