IDN-POS CAFE

import 'dart:async';
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;

const String kCrashApiUrl = 'https://manage-app.idnacode.my.id/api/v1/errors';
const String kAppApiKey = 'app_live_BWMXuKNis9J9xMpMc0wU84irapoXLvukpMjBCkmH';

Future<void> reportMobileError(Object error, StackTrace? stackTrace, {String severity = 'fatal'}) async {
  try {
    await http.post(
      Uri.parse(kCrashApiUrl),
      headers: {
        'Content-Type': 'application/json',
        'X-App-Key': kAppApiKey,
      },
      body: jsonEncode({
        'exception_class': error.runtimeType.toString(),
        'message': error.toString(),
        'severity': severity,
        'stack_trace': stackTrace?.toString(),
        'os_name': defaultTargetPlatform.name,
        'app_version': '1.0.0',
        'breadcrumbs': [
          {'category': 'lifecycle', 'message': 'App running', 'timestamp': DateTime.now().toIso8601String()}
        ],
      }),
    );
  } catch (_) {}
}

void main() {
  FlutterError.onError = (FlutterErrorDetails details) {
    FlutterError.presentError(details);
    reportMobileError(details.exception, details.stack);
  };

  PlatformDispatcher.instance.onError = (error, stack) {
    reportMobileError(error, stack);
    return true;
  };

  runApp(const MyApp());
}

import { Platform } from 'react-native';

const CRASH_API_URL = 'https://manage-app.idnacode.my.id/api/v1/errors';
const APP_API_KEY = 'app_live_BWMXuKNis9J9xMpMc0wU84irapoXLvukpMjBCkmH';

export const reportError = async (error, isFatal = false) => {
  try {
    await fetch(CRASH_API_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-App-Key': APP_API_KEY,
      },
      body: JSON.stringify({
        exception_class: error.name || 'Error',
        message: error.message || String(error),
        severity: isFatal ? 'fatal' : 'error',
        stack_trace: error.stack || '',
        os_name: Platform.OS === 'ios' ? 'iOS' : 'Android',
        os_version: String(Platform.Version),
        app_version: '1.0.0',
      }),
    });
  } catch (e) {}
};

if (global.ErrorUtils) {
  const defaultHandler = global.ErrorUtils.getGlobalHandler();
  global.ErrorUtils.setGlobalHandler((error, isFatal) => {
    reportError(error, isFatal);
    defaultHandler(error, isFatal);
  });
}

import android.os.Build
import org.json.JSONObject
import java.io.OutputStreamWriter
import java.net.HttpURLConnection
import java.net.URL
import kotlin.concurrent.thread

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
            reportCrash(throwable)
            defaultHandler?.uncaughtException(thread, throwable)
        }
    }

    private fun reportCrash(t: Throwable) {
        thread {
            try {
                val url = URL("https://manage-app.idnacode.my.id/api/v1/errors")
                val conn = url.openConnection() as HttpURLConnection
                conn.requestMethod = "POST"
                conn.setRequestProperty("Content-Type", "application/json")
                conn.setRequestProperty("X-App-Key", "app_live_BWMXuKNis9J9xMpMc0wU84irapoXLvukpMjBCkmH")
                conn.doOutput = true

                val json = JSONObject().apply {
                    put("exception_class", t.javaClass.simpleName)
                    put("message", t.message ?: "Unknown crash")
                    put("severity", "fatal")
                    put("stack_trace", android.util.Log.getStackTraceString(t))
                    put("os_name", "Android")
                    put("os_version", Build.VERSION.RELEASE)
                    put("device_model", Build.MODEL)
                }

                OutputStreamWriter(conn.outputStream).use { it.write(json.toString()) }
                conn.responseCode
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
}

import UIKit

func sendCrashReport(name: String, reason: String, stack: [String]) {
    guard let url = URL(string: "https://manage-app.idnacode.my.id/api/v1/errors") else { return }
    var req = URLRequest(url: url)
    req.httpMethod = "POST"
    req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    req.setValue("app_live_BWMXuKNis9J9xMpMc0wU84irapoXLvukpMjBCkmH", forHTTPHeaderField: "X-App-Key")

    let payload: [String: Any] = [
        "exception_class": name,
        "message": reason,
        "severity": "fatal",
        "stack_trace": stack.joined(separator: "\n"),
        "os_name": "iOS",
        "os_version": UIDevice.current.systemVersion,
        "device_model": UIDevice.current.model
    ]

    req.httpBody = try? JSONSerialization.data(withJSONObject: payload)
    URLSession.shared.dataTask(with: req).resume()
}

NSSetUncaughtExceptionHandler { exception in
    sendCrashReport(
        name: exception.name.rawValue,
        reason: exception.reason ?? "Crash",
        stack: exception.callStackSymbols
    )
}

curl -X POST "https://manage-app.idnacode.my.id/api/v1/errors" \
  -H "Content-Type: application/json" \
  -H "X-App-Key: app_live_BWMXuKNis9J9xMpMc0wU84irapoXLvukpMjBCkmH" \
  -d '{
    "exception_class": "NullPointerException",
    "message": "Attempt to invoke method on null object reference",
    "severity": "error",
    "stack_trace": "at com.example.MainActivity.onCreate(MainActivity.kt:42)",
    "app_version": "1.0.0",
    "os_name": "Android"
  }'