@boshyxd/rosentry 0.1.0

package/out/internal/Transport.luau

@@ -0,0 +1,140 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local HttpService = _services.HttpService
+local ReplicatedStorage = _services.ReplicatedStorage
+local RunService = _services.RunService
+local IS_SERVER = RunService:IsServer()
+local IS_CLIENT = RunService:IsClient()
+local REMOTE_EVENT_NAME = "RoSentryRelay"
+local Transport
+do
+	Transport = setmetatable({}, {
+		__tostring = function()
+			return "Transport"
+		end,
+	})
+	Transport.__index = Transport
+	function Transport.new(...)
+		local self = setmetatable({}, Transport)
+		return self:constructor(...) or self
+	end
+	function Transport:constructor(config)
+		self._config = config
+	end
+	function Transport:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:Transport]", unpack(args))
+		end
+	end
+	function Transport:_getRemoteEvent()
+		if self._remoteEvent then
+			return self._remoteEvent
+		end
+		if IS_SERVER then
+			local existing = ReplicatedStorage:FindFirstChild(REMOTE_EVENT_NAME)
+			if existing and existing:IsA("RemoteEvent") then
+				self._remoteEvent = existing
+			else
+				local remote = Instance.new("RemoteEvent")
+				remote.Name = REMOTE_EVENT_NAME
+				remote.Parent = ReplicatedStorage
+				self._remoteEvent = remote
+			end
+		else
+			local found = ReplicatedStorage:WaitForChild(REMOTE_EVENT_NAME, 10)
+			if found and found:IsA("RemoteEvent") then
+				self._remoteEvent = found
+			else
+				self:_debug("RemoteEvent not found - server may not have RoSentry initialized")
+			end
+		end
+		return self._remoteEvent
+	end
+	function Transport:setupServerRelay()
+		if not IS_SERVER then
+			return nil
+		end
+		local remote = self:_getRemoteEvent()
+		if not remote then
+			return nil
+		end
+		remote.OnServerEvent:Connect(function(player, payload)
+			self:_debug("Received client errors from", player.Name)
+			local p = payload
+			if p.errors then
+				for _, errorData in p.errors do
+					errorData.context = errorData.context or {}
+					errorData.context.relayedFrom = "client"
+					errorData.context.playerName = player.Name
+					errorData.context.playerId = player.UserId
+				end
+			end
+			self:_sendHttp(payload)
+		end)
+		self:_debug("Server relay setup complete")
+	end
+	function Transport:_sendHttp(payload)
+		local apiKey = self._config:get("apiKey")
+		local endpoint = self._config:get("endpoint")
+		if apiKey == "" then
+			self:_debug("No API key configured")
+			return false
+		end
+		local success, result = pcall(function()
+			local response = HttpService:RequestAsync({
+				Url = endpoint,
+				Method = "POST",
+				Headers = {
+					["Content-Type"] = "application/json",
+					["x-api-key"] = apiKey,
+				},
+				Body = HttpService:JSONEncode(payload),
+			})
+			return response.Success
+		end)
+		if not success then
+			self:_debug("Request failed:", result)
+			return false
+		end
+		self:_debug("Request sent successfully")
+		return result
+	end
+	function Transport:_sendRemote(payload)
+		local remote = self:_getRemoteEvent()
+		if not remote then
+			self:_debug("Cannot send - RemoteEvent not available")
+			return false
+		end
+		local success, err = pcall(function()
+			remote:FireServer(payload)
+		end)
+		if not success then
+			self:_debug("Remote send failed:", err)
+			return false
+		end
+		self:_debug("Sent to server via RemoteEvent")
+		return true
+	end
+	function Transport:send(payload)
+		if not self._config:isEnabled() then
+			self:_debug("SDK disabled, skipping send")
+			return false
+		end
+		if IS_SERVER then
+			return self:_sendHttp(payload)
+		elseif IS_CLIENT then
+			return self:_sendRemote(payload)
+		end
+		return false
+	end
+	function Transport:sendAsync(payload)
+		task.spawn(function()
+			self:send(payload)
+		end)
+	end
+end
+return {
+	Transport = Transport,
+}

package/out/internal/util.d.ts

@@ -0,0 +1,9 @@
+export declare function generateUUID(): string;
+export declare function getJobId(): string;
+export declare function getPlaceId(): number;
+export declare function getGameVersion(): string;
+export declare function isServer(): boolean;
+export declare function sanitizeStackTrace(trace?: string): string | undefined;
+export declare function deepCopy<T>(original: T): T;
+export declare function merge<T extends object>(base: T, override?: Partial<T>): T;
+export declare function getTimestamp(): string;

package/out/internal/util.luau

@@ -0,0 +1,68 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local function generateUUID()
+	local template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+	return (string.gsub(template, "[xy]", function(c)
+		local v = if c == "x" then math.random(0, 15) else math.random(8, 11)
+		return string.format("%x", v)
+	end))
+end
+local function getJobId()
+	return if game.JobId ~= "" then game.JobId else "local"
+end
+local function getPlaceId()
+	return game.PlaceId
+end
+local function getGameVersion()
+	return tostring(game.PlaceVersion)
+end
+local function isServer()
+	return RunService:IsServer()
+end
+local function sanitizeStackTrace(trace)
+	if trace == nil then
+		return nil
+	end
+	local lines = {}
+	for line in string.gmatch(trace, "[^\n]+") do
+		local cleaned = string.gsub(line, "^%s+", "")
+		table.insert(lines, cleaned)
+	end
+	return table.concat(lines, "\n")
+end
+local function deepCopy(original)
+	local _original = original
+	if not (type(_original) == "table") then
+		return original
+	end
+	local copy = {}
+	for key, value in pairs(original) do
+		copy[key] = deepCopy(value)
+	end
+	return copy
+end
+local function merge(base, override)
+	if override == nil then
+		return base
+	end
+	local result = deepCopy(base)
+	for key, value in pairs(override) do
+		result[key] = value
+	end
+	return result
+end
+local function getTimestamp()
+	return DateTime.now():ToIsoDate()
+end
+return {
+	generateUUID = generateUUID,
+	getJobId = getJobId,
+	getPlaceId = getPlaceId,
+	getGameVersion = getGameVersion,
+	isServer = isServer,
+	sanitizeStackTrace = sanitizeStackTrace,
+	deepCopy = deepCopy,
+	merge = merge,
+	getTimestamp = getTimestamp,
+}

package/out/types.d.ts

@@ -0,0 +1,94 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface Config {
+    apiKey: string;
+    environment: string;
+    endpoint: string;
+    enabled: boolean;
+    sampleRate: number;
+    maxBreadcrumbs: number;
+    maxQueueSize: number;
+    flushInterval: number;
+    debug: boolean;
+    autoCapture: boolean;
+    captureWarnings: boolean;
+    beforeSend?: (errorData: ErrorData) => ErrorData | undefined;
+}
+export interface ConfigOptions {
+    apiKey?: string;
+    environment?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    sampleRate?: number;
+    maxBreadcrumbs?: number;
+    maxQueueSize?: number;
+    flushInterval?: number;
+    debug?: boolean;
+    autoCapture?: boolean;
+    captureWarnings?: boolean;
+    beforeSend?: (errorData: ErrorData) => ErrorData | undefined;
+}
+export interface Breadcrumb {
+    category: string;
+    message: string;
+    data?: Map<string, unknown>;
+    timestamp: number;
+}
+export interface UserContext {
+    id: number;
+    name?: string;
+    data: Map<string, unknown>;
+}
+export interface ErrorContext {
+    userData?: Map<string, unknown>;
+    custom?: Map<string, unknown>;
+    breadcrumbs?: Breadcrumb[];
+    isServer: boolean;
+    script?: string;
+    trace?: Map<string, unknown>;
+}
+export interface ErrorData {
+    message: string;
+    level: LogLevel;
+    stack_trace?: string;
+    user_id?: number;
+    player_name?: string;
+    trace_id?: string;
+    job_id: string;
+    place_id: number;
+    game_version: string;
+    environment: string;
+    context: ErrorContext;
+    tags: string[];
+    timestamp: string;
+}
+export interface CaptureOptions {
+    level?: LogLevel;
+    stackTrace?: string;
+    context?: Map<string, unknown>;
+    tags?: string[];
+}
+export interface ScopeInterface {
+    setUser: (userId: number, playerName?: string, data?: Map<string, unknown>) => void;
+    clearUser: () => void;
+    addBreadcrumb: (category: string, message: string, data?: Map<string, unknown>) => void;
+    setTag: (key: string, value: string) => void;
+    setExtra: (key: string, value: unknown) => void;
+}
+export type TraceStatus = "active" | "completed" | "error" | "timeout";
+export interface TraceOptions {
+    maxEvents?: number;
+    expiresIn?: number;
+    tags?: string[];
+    metadata?: Map<string, unknown>;
+}
+export interface Trace {
+    id: string;
+    name: string;
+    log: (message: string, data?: Map<string, unknown>) => void;
+    debug: (message: string, data?: Map<string, unknown>) => void;
+    info: (message: string, data?: Map<string, unknown>) => void;
+    warn: (message: string, data?: Map<string, unknown>) => void;
+    error: (message: string, data?: Map<string, unknown>) => void;
+    isActive: () => boolean;
+    finish: (status?: TraceStatus) => void;
+}

package/out/types.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@boshyxd/rosentry",
+	"version": "0.1.0",
+	"description": "Error monitoring SDK for Roblox",
+	"main": "out/init.lua",
+	"types": "out/index.d.ts",
+	"typings": "out/index.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/boshyxd/rosentry"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "rbxtsc",
+		"build:dev": "rbxtsc --type game -i include",
+		"watch": "rbxtsc -w",
+		"watch:dev": "rbxtsc -w --type game -i include"
+	},
+	"keywords": ["roblox", "roblox-ts", "error-monitoring", "sentry"],
+	"author": "boshyxd",
+	"license": "MIT",
+	"dependencies": {
+		"@rbxts/services": "^1.5.1"
+	},
+	"devDependencies": {
+		"@rbxts/compiler-types": "^3.0.0-types.0",
+		"@rbxts/types": "^1.0.838",
+		"roblox-ts": "^3.0.0",
+		"typescript": "^5.6.3"
+	},
+	"files": ["out"]
+}