rendertrace

func TestTraceEnabledAtBootReadsBooleanAndObjectFlags(t *testing.T)

{
	global := js.Global()
	previous := global.Get("RFW_RENDER_TRACE")
	defer func() {
		if previous.Type() == js.TypeUndefined {
			global.Get("Reflect").Call("deleteProperty", global, "RFW_RENDER_TRACE")
			return
		}
		global.Set("RFW_RENDER_TRACE", previous)
	}()

	global.Set("RFW_RENDER_TRACE", true)
	if !traceEnabledAtBoot() {
		t.Fatal("boolean true did not enable tracing")
	}
	global.Set("RFW_RENDER_TRACE", map[string]any{"enabled": true})
	if !traceEnabledAtBoot() {
		t.Fatal("object enabled flag did not enable tracing")
	}
	global.Set("RFW_RENDER_TRACE", false)
	if traceEnabledAtBoot() {
		t.Fatal("boolean false enabled tracing")
	}
}

func traceEnabledAtBoot() bool

{
	value := js.Global().Get("RFW_RENDER_TRACE")
	if value.Type() == js.TypeBoolean {
		return value.Bool()
	}
	if value.Type() == js.TypeObject {
		enabled := value.Get("enabled")
		return enabled.Type() == js.TypeBoolean && enabled.Bool()
	}
	return false
}

func Emit(record Record)

{
	if !Enabled() {
		return
	}
	defer func() { _ = recover() }()

	detail := map[string]any{
		"schemaVersion": schemaVersion,
		"sequence":      sequence.Add(1),
		"timestampMs":   NowMS(),
		"event":         record.Event,
		"batchId":       record.BatchID,
		"renderId":      record.RenderID,
		"componentId":   record.ComponentID,
		"componentName": record.ComponentName,
		"depth":         record.Depth,
	}
	if record.ParentComponentID != "" {
		detail["parentComponentId"] = record.ParentComponentID
	}
	if record.Cause.Kind != "" {
		detail["cause"] = causeDetail(record.Cause)
	}
	if len(record.Causes) > 0 {
		causes := make([]any, 0, len(record.Causes))
		for _, cause := range record.Causes {
			causes = append(causes, causeDetail(cause))
		}
		detail["causes"] = causes
	}
	if record.QueueDepth > 0 {
		detail["queueDepth"] = record.QueueDepth
	}
	if record.CoalescedCount > 0 || record.Event == "scheduled" || record.Event == "coalesced" || record.Event == "started" || record.Event == "committed" {
		detail["coalescedCount"] = record.CoalescedCount
	}
	if record.Event == "committed" || record.Event == "failed" {
		detail["templateMs"] = record.TemplateMS
		detail["domMs"] = record.DOMMS
		detail["totalMs"] = record.TotalMS
	}
	if record.Outcome != "" {
		detail["outcome"] = record.Outcome
	}
	if record.Reason != "" {
		detail["reason"] = record.Reason
	}
	if record.SupersededBy != 0 {
		detail["supersededByRenderId"] = record.SupersededBy
	}

	constructor := js.Global().Get("CustomEvent")
	dispatch := js.Global().Get("dispatchEvent")
	if constructor.Type() != js.TypeFunction || dispatch.Type() != js.TypeFunction {
		return
	}
	options := map[string]any{"detail": detail}
	event := constructor.New("rfw:render-trace", options)
	js.Global().Call("dispatchEvent", event)
}

func causeDetail(cause Cause) map[string]any

{
	cause = NormalizeCause(cause)
	detail := map[string]any{"kind": cause.Kind}
	if cause.Module != "" {
		detail["module"] = cause.Module
	}
	if cause.Store != "" {
		detail["store"] = cause.Store
	}
	if cause.Key != "" {
		detail["key"] = cause.Key
	}
	if cause.Signal != "" {
		detail["signal"] = cause.Signal
	}
	return detail
}