Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 handler.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package qlog import ( "context" "log/slog" ) type withAttrsHandler struct { attrs []slog.Attr h slog.Handler } func withAttrs(h slog.Handler, attrs []slog.Attr) slog.Handler { if len(attrs) == 0 { return h } return &withAttrsHandler{attrs: attrs, h: h} } func (h withAttrsHandler) Enabled(ctx context.Context, level slog.Level) bool { return h.h.Enabled(ctx, level) } func (h withAttrsHandler) Handle(ctx context.Context, r slog.Record) error { r.AddAttrs(h.attrs...) return h.h.Handle(ctx, r) } func (h withAttrsHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return withAttrs(h, attrs) } func (h withAttrsHandler) WithGroup(name string) slog.Handler { return withGroup(h, name) } type withGroupHandler struct { name string h slog.Handler } func withGroup(h slog.Handler, name string) slog.Handler { if name == "" { return h } return &withGroupHandler{name: name, h: h} } func (h withGroupHandler) Enabled(ctx context.Context, level slog.Level) bool { return h.h.Enabled(ctx, level) } func (h withGroupHandler) Handle(ctx context.Context, r slog.Record) error { var attrs []slog.Attr r.Attrs(func(a slog.Attr) bool { attrs = append(attrs, a) return true }) nr := slog.NewRecord(r.Time, r.Level, r.Message, r.PC) nr.Add(slog.Any(h.name, slog.GroupValue(attrs...))) return h.h.Handle(ctx, nr) } func (h withGroupHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return withAttrs(h, attrs) } func (h withGroupHandler) WithGroup(name string) slog.Handler { return withGroup(h, name) }	1.69 KB	2025-05-25 12:27
📄 json_writer.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package qlog import ( "bytes" "fmt" "io" "log/slog" "strconv" "sync" "time" ) // A jsonWriter writes JSON-SEQ (RFC 7464). // // A JSON-SEQ file consists of a series of JSON text records, // each beginning with an RS (0x1e) character and ending with LF (0x0a). type jsonWriter struct { mu sync.Mutex w io.WriteCloser buf bytes.Buffer } // writeRecordStart writes the start of a JSON-SEQ record. func (w jsonWriter) writeRecordStart() { w.mu.Lock() w.buf.WriteByte(0x1e) w.buf.WriteByte('{') } // writeRecordEnd finishes writing a JSON-SEQ record. func (w jsonWriter) writeRecordEnd() { w.buf.WriteByte('}') w.buf.WriteByte('\n') w.w.Write(w.buf.Bytes()) w.buf.Reset() w.mu.Unlock() } func (w jsonWriter) writeAttrs(attrs []slog.Attr) { w.buf.WriteByte('{') for _, a := range attrs { w.writeAttr(a) } w.buf.WriteByte('}') } func (w jsonWriter) writeAttr(a slog.Attr) { if a.Key == "" { return } w.writeName(a.Key) w.writeValue(a.Value) } // writeAttr writes a []slog.Attr as an object field. func (w jsonWriter) writeAttrsField(name string, attrs []slog.Attr) { w.writeName(name) w.writeAttrs(attrs) } func (w jsonWriter) writeValue(v slog.Value) { v = v.Resolve() switch v.Kind() { case slog.KindAny: switch v := v.Any().(type) { case []slog.Value: w.writeArray(v) case interface{ AppendJSON([]byte) []byte }: w.buf.Write(v.AppendJSON(w.buf.AvailableBuffer())) default: w.writeString(fmt.Sprint(v)) } case slog.KindBool: w.writeBool(v.Bool()) case slog.KindDuration: w.writeDuration(v.Duration()) case slog.KindFloat64: w.writeFloat64(v.Float64()) case slog.KindInt64: w.writeInt64(v.Int64()) case slog.KindString: w.writeString(v.String()) case slog.KindTime: w.writeTime(v.Time()) case slog.KindUint64: w.writeUint64(v.Uint64()) case slog.KindGroup: w.writeAttrs(v.Group()) default: w.writeString("unhandled kind") } } // writeName writes an object field name followed by a colon. func (w jsonWriter) writeName(name string) { if b := w.buf.Bytes(); len(b) > 0 && b[len(b)-1] != '{' { // Add the comma separating this from the previous field. w.buf.WriteByte(',') } w.writeString(name) w.buf.WriteByte(':') } func (w jsonWriter) writeObject(f func()) { w.buf.WriteByte('{') f() w.buf.WriteByte('}') } // writeObject writes an object-valued object field. // The function f is called to write the contents. func (w jsonWriter) writeObjectField(name string, f func()) { w.writeName(name) w.writeObject(f) } func (w jsonWriter) writeArray(vals []slog.Value) { w.buf.WriteByte('[') for i, v := range vals { if i != 0 { w.buf.WriteByte(',') } w.writeValue(v) } w.buf.WriteByte(']') } func (w jsonWriter) writeRaw(v string) { w.buf.WriteString(v) } // writeRawField writes a field with a raw JSON value. func (w jsonWriter) writeRawField(name, v string) { w.writeName(name) w.writeRaw(v) } func (w jsonWriter) writeBool(v bool) { if v { w.buf.WriteString("true") } else { w.buf.WriteString("false") } } // writeBoolField writes a bool-valued object field. func (w jsonWriter) writeBoolField(name string, v bool) { w.writeName(name) w.writeBool(v) } // writeDuration writes a duration as milliseconds. func (w jsonWriter) writeDuration(v time.Duration) { if v < 0 { w.buf.WriteByte('-') v = -v } fmt.Fprintf(&w.buf, "%d.%06d", v.Milliseconds(), v%time.Millisecond) } // writeDurationField writes a millisecond duration-valued object field. func (w jsonWriter) writeDurationField(name string, v time.Duration) { w.writeName(name) w.writeDuration(v) } func (w jsonWriter) writeFloat64(v float64) { w.buf.Write(strconv.AppendFloat(w.buf.AvailableBuffer(), v, 'f', -1, 64)) } // writeFloat64Field writes an float64-valued object field. func (w jsonWriter) writeFloat64Field(name string, v float64) { w.writeName(name) w.writeFloat64(v) } func (w jsonWriter) writeInt64(v int64) { w.buf.Write(strconv.AppendInt(w.buf.AvailableBuffer(), v, 10)) } // writeInt64Field writes an int64-valued object field. func (w jsonWriter) writeInt64Field(name string, v int64) { w.writeName(name) w.writeInt64(v) } func (w jsonWriter) writeUint64(v uint64) { w.buf.Write(strconv.AppendUint(w.buf.AvailableBuffer(), v, 10)) } // writeUint64Field writes a uint64-valued object field. func (w jsonWriter) writeUint64Field(name string, v uint64) { w.writeName(name) w.writeUint64(v) } // writeTime writes a time as seconds since the Unix epoch. func (w jsonWriter) writeTime(v time.Time) { fmt.Fprintf(&w.buf, "%d.%06d", v.UnixMilli(), v.Nanosecond()%int(time.Millisecond)) } // writeTimeField writes a time-valued object field. func (w jsonWriter) writeTimeField(name string, v time.Time) { w.writeName(name) w.writeTime(v) } func jsonSafeSet(c byte) bool { // mask is a 128-bit bitmap with 1s for allowed bytes, // so that the byte c can be tested with a shift and an and. // If c > 128, then 1<<c and 1<<(c-64) will both be zero, // and this function will return false. const mask = 0 \| (1<<(0x22-0x20)-1)<<0x20 \| (1<<(0x5c-0x23)-1)<<0x23 \| (1<<(0x7f-0x5d)-1)<<0x5d return ((uint64(1)<<c)&(mask&(1<<64-1)) \| (uint64(1)<<(c-64))&(mask>>64)) != 0 } func jsonNeedsEscape(s string) bool { for i := range s { if !jsonSafeSet(s[i]) { return true } } return false } // writeString writes an ASCII string. // // qlog fields should never contain anything that isn't ASCII, // so we do the bare minimum to avoid producing invalid output if we // do write something unexpected. func (w jsonWriter) writeString(v string) { w.buf.WriteByte('"') if !jsonNeedsEscape(v) { w.buf.WriteString(v) } else { for i := range v { if jsonSafeSet(v[i]) { w.buf.WriteByte(v[i]) } else { fmt.Fprintf(&w.buf, `\u%04x`, v[i]) } } } w.buf.WriteByte('"') } // writeStringField writes a string-valued object field. func (w jsonWriter) writeStringField(name, v string) { w.writeName(name) w.writeString(v) }	6.03 KB	2025-05-25 12:27
📄 json_writer_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package qlog import ( "bytes" "errors" "fmt" "log/slog" "strings" "sync" "testing" "time" ) type testJSONOut struct { bytes.Buffer } func (o testJSONOut) Close() error { return nil } func newTestJSONWriter() jsonWriter { return &jsonWriter{w: &testJSONOut{}} } func wantJSONRecord(t testing.T, w jsonWriter, want string) { t.Helper() want = "\x1e" + want + "\n" got := w.w.(testJSONOut).String() if got != want { t.Errorf("jsonWriter contains unexpected output\ngot: %q\nwant: %q", got, want) } } func TestJSONWriterWriteConcurrentRecords(t testing.T) { w := newTestJSONWriter() var wg sync.WaitGroup for i := 0; i < 3; i++ { wg.Add(1) go func() { defer wg.Done() w.writeRecordStart() w.writeInt64Field("field", 0) w.writeRecordEnd() }() } wg.Wait() wantJSONRecord(t, w, strings.Join([]string{ `{"field":0}`, `{"field":0}`, `{"field":0}`, }, "\n\x1e")) } func TestJSONWriterAttrs(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeAttrsField("field", []slog.Attr{ slog.Any("any", errors.New("value")), slog.Bool("bool", true), slog.Duration("duration", 1time.Second), slog.Float64("float64", 1), slog.Int64("int64", 1), slog.String("string", "value"), slog.Time("time", time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)), slog.Uint64("uint64", 1), slog.Group("group", "a", 1), }) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":{`+ `"any":"value",`+ `"bool":true,`+ `"duration":1000.000000,`+ `"float64":1,`+ `"int64":1,`+ `"string":"value",`+ `"time":946684800000.000000,`+ `"uint64":1,`+ `"group":{"a":1}`+ `}}`) } func TestJSONWriterAttrEmpty(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() var a slog.Attr w.writeAttr(a) w.writeRecordEnd() wantJSONRecord(t, w, `{}`) } func TestJSONWriterObjectEmpty(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeObjectField("field", func() {}) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":{}}`) } func TestJSONWriterObjectFields(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeObjectField("field", func() { w.writeStringField("a", "value") w.writeInt64Field("b", 10) }) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":{"a":"value","b":10}}`) } func TestJSONWriterRawField(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeRawField("field", `[1]`) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":[1]}`) } func TestJSONWriterBoolField(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeBoolField("true", true) w.writeBoolField("false", false) w.writeRecordEnd() wantJSONRecord(t, w, `{"true":true,"false":false}`) } func TestJSONWriterDurationField(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeDurationField("field1", (10time.Millisecond)+(2time.Nanosecond)) w.writeDurationField("field2", -((10 * time.Millisecond) + (2 * time.Nanosecond))) w.writeRecordEnd() wantJSONRecord(t, w, `{"field1":10.000002,"field2":-10.000002}`) } func TestJSONWriterFloat64Field(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeFloat64Field("field", 1.1) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":1.1}`) } func TestJSONWriterInt64Field(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeInt64Field("field", 1234) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":1234}`) } func TestJSONWriterUint64Field(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeUint64Field("field", 1234) w.writeRecordEnd() wantJSONRecord(t, w, `{"field":1234}`) } func TestJSONWriterStringField(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeStringField("field", "value") w.writeRecordEnd() wantJSONRecord(t, w, `{"field":"value"}`) } func TestJSONWriterStringFieldEscaped(t testing.T) { w := newTestJSONWriter() w.writeRecordStart() w.writeStringField("field", "va\x00ue") w.writeRecordEnd() wantJSONRecord(t, w, `{"field":"va\u0000ue"}`) } func TestJSONWriterStringEscaping(t testing.T) { for c := 0; c <= 0xff; c++ { w := newTestJSONWriter() w.writeRecordStart() w.writeStringField("field", string([]byte{byte(c)})) w.writeRecordEnd() var want string if (c >= 0x20 && c <= 0x21) \|\| (c >= 0x23 && c <= 0x5b) \|\| (c >= 0x5d && c <= 0x7e) { want = fmt.Sprintf(`%c`, c) } else { want = fmt.Sprintf(`\u%04x`, c) } wantJSONRecord(t, w, `{"field":"`+want+`"}`) } }	4.58 KB	2025-05-25 12:27
📄 qlog.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 // Package qlog serializes qlog events. package qlog import ( "bytes" "context" "errors" "io" "log/slog" "os" "path/filepath" "sync" "time" ) // Vantage is the vantage point of a trace. type Vantage string const ( // VantageEndpoint traces contain events not specific to a single connection. VantageEndpoint = Vantage("endpoint") // VantageClient traces follow a connection from the client's perspective. VantageClient = Vantage("client") // VantageServer traces follow a connection from the server's perspective. VantageServer = Vantage("server") ) // TraceInfo contains information about a trace. type TraceInfo struct { // Vantage is the vantage point of the trace. Vantage Vantage // GroupID identifies the logical group the trace belongs to. // For a connection trace, the group will be the same for // both the client and server vantage points. GroupID string } // HandlerOptions are options for a JSONHandler. type HandlerOptions struct { // Level reports the minimum record level that will be logged. // If Level is nil, the handler assumes QLogLevelEndpoint. Level slog.Leveler // Dir is the directory in which to create trace files. // The handler will create one file per connection. // If NewTrace is non-nil or Dir is "", the handler will not create files. Dir string // NewTrace is called to create a new trace. // If NewTrace is nil and Dir is set, // the handler will create a new file in Dir for each trace. NewTrace func(TraceInfo) (io.WriteCloser, error) } type endpointHandler struct { opts HandlerOptions traceOnce sync.Once trace jsonTraceHandler } // NewJSONHandler returns a handler which serializes qlog events to JSON. // // The handler will write an endpoint-wide trace, // and a separate trace for each connection. // The HandlerOptions control the location traces are written. // // It uses the streamable JSON Text Sequences mapping (JSON-SEQ) // defined in draft-ietf-quic-qlog-main-schema-04, Section 6.2. // // A JSONHandler may be used as the handler for a quic.Config.QLogLogger. // It is not a general-purpose slog handler, // and may not properly handle events from other sources. func NewJSONHandler(opts HandlerOptions) slog.Handler { if opts.Dir == "" && opts.NewTrace == nil { return slogDiscard{} } return &endpointHandler{ opts: opts, } } func (h endpointHandler) Enabled(ctx context.Context, level slog.Level) bool { return enabled(h.opts.Level, level) } func (h endpointHandler) Handle(ctx context.Context, r slog.Record) error { h.traceOnce.Do(func() { h.trace, _ = newJSONTraceHandler(h.opts, nil) }) if h.trace != nil { h.trace.Handle(ctx, r) } return nil } func (h endpointHandler) WithAttrs(attrs []slog.Attr) slog.Handler { // Create a new trace output file for each top-level WithAttrs. tr, err := newJSONTraceHandler(h.opts, attrs) if err != nil { return withAttrs(h, attrs) } return tr } func (h endpointHandler) WithGroup(name string) slog.Handler { return withGroup(h, name) } type jsonTraceHandler struct { level slog.Leveler w jsonWriter start time.Time buf bytes.Buffer } func newJSONTraceHandler(opts HandlerOptions, attrs []slog.Attr) (jsonTraceHandler, error) { w, err := newTraceWriter(opts, traceInfoFromAttrs(attrs)) if err != nil { return nil, err } // For testing, it might be nice to set the start time used for relative timestamps // to the time of the first event. // // At the expense of some additional complexity here, we could defer writing // the reference_time header field until the first event is processed. // // Just use the current time for now. start := time.Now() h := &jsonTraceHandler{ w: jsonWriter{w: w}, level: opts.Level, start: start, } h.writeHeader(attrs) return h, nil } func traceInfoFromAttrs(attrs []slog.Attr) TraceInfo { info := TraceInfo{ Vantage: VantageEndpoint, // default if not specified } for _, a := range attrs { if a.Key == "group_id" && a.Value.Kind() == slog.KindString { info.GroupID = a.Value.String() } if a.Key == "vantage_point" && a.Value.Kind() == slog.KindGroup { for _, aa := range a.Value.Group() { if aa.Key == "type" && aa.Value.Kind() == slog.KindString { info.Vantage = Vantage(aa.Value.String()) } } } } return info } func newTraceWriter(opts HandlerOptions, info TraceInfo) (io.WriteCloser, error) { var w io.WriteCloser var err error if opts.NewTrace != nil { w, err = opts.NewTrace(info) } else if opts.Dir != "" { var filename string if info.GroupID != "" { filename = info.GroupID + "_" } filename += string(info.Vantage) + ".sqlog" if !filepath.IsLocal(filename) { return nil, errors.New("invalid trace filename") } w, err = os.OpenFile(filepath.Join(opts.Dir, filename), os.O_CREATE\|os.O_EXCL\|os.O_WRONLY, 0666) } else { err = errors.New("no log destination") } return w, err } func (h jsonTraceHandler) writeHeader(attrs []slog.Attr) { h.w.writeRecordStart() defer h.w.writeRecordEnd() // At the time of writing this comment the most recent version is 0.4, // but qvis only supports up to 0.3. h.w.writeStringField("qlog_version", "0.3") h.w.writeStringField("qlog_format", "JSON-SEQ") // The attrs flatten both common trace event fields and Trace fields. // This identifies the fields that belong to the Trace. isTraceSeqField := func(s string) bool { switch s { case "title", "description", "configuration", "vantage_point": return true } return false } h.w.writeObjectField("trace", func() { h.w.writeObjectField("common_fields", func() { h.w.writeRawField("protocol_type", `["QUIC"]`) h.w.writeStringField("time_format", "relative") h.w.writeTimeField("reference_time", h.start) for _, a := range attrs { if !isTraceSeqField(a.Key) { h.w.writeAttr(a) } } }) for _, a := range attrs { if isTraceSeqField(a.Key) { h.w.writeAttr(a) } } }) } func (h jsonTraceHandler) Enabled(ctx context.Context, level slog.Level) bool { return enabled(h.level, level) } func (h jsonTraceHandler) Handle(ctx context.Context, r slog.Record) error { h.w.writeRecordStart() defer h.w.writeRecordEnd() h.w.writeDurationField("time", r.Time.Sub(h.start)) h.w.writeStringField("name", r.Message) h.w.writeObjectField("data", func() { r.Attrs(func(a slog.Attr) bool { h.w.writeAttr(a) return true }) }) return nil } func (h jsonTraceHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return withAttrs(h, attrs) } func (h *jsonTraceHandler) WithGroup(name string) slog.Handler { return withGroup(h, name) } func enabled(leveler slog.Leveler, level slog.Level) bool { var minLevel slog.Level if leveler != nil { minLevel = leveler.Level() } return level >= minLevel } type slogDiscard struct{} func (slogDiscard) Enabled(context.Context, slog.Level) bool { return false } func (slogDiscard) Handle(ctx context.Context, r slog.Record) error { return nil } func (slogDiscard) WithAttrs(attrs []slog.Attr) slog.Handler { return slogDiscard{} } func (slogDiscard) WithGroup(name string) slog.Handler { return slogDiscard{} }	7.17 KB	2025-05-25 12:27
📄 qlog_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package qlog import ( "bytes" "encoding/json" "fmt" "io" "log/slog" "reflect" "testing" "time" ) // QLog tests are mostly in the quic package, where we can test event generation // and serialization together. func TestQLogHandlerEvents(t testing.T) { for _, test := range []struct { name string f func(slog.Logger) want []map[string]any // events, not counting the trace header }{{ name: "various types", f: func(log slog.Logger) { log.Info("message", "bool", true, "duration", time.Duration(1time.Second), "float", 0.0, "int", 0, "string", "value", "uint", uint64(0), slog.Group("group", "a", 0, ), ) }, want: []map[string]any{{ "name": "message", "data": map[string]any{ "bool": true, "duration": float64(1000), "float": float64(0.0), "int": float64(0), "string": "value", "uint": float64(0), "group": map[string]any{ "a": float64(0), }, }, }}, }, { name: "WithAttrs", f: func(log slog.Logger) { log = log.With( "with_a", "a", "with_b", "b", ) log.Info("m1", "field", "1") log.Info("m2", "field", "2") }, want: []map[string]any{{ "name": "m1", "data": map[string]any{ "with_a": "a", "with_b": "b", "field": "1", }, }, { "name": "m2", "data": map[string]any{ "with_a": "a", "with_b": "b", "field": "2", }, }}, }, { name: "WithGroup", f: func(log slog.Logger) { log = log.With( "with_a", "a", "with_b", "b", ) log.Info("m1", "field", "1") log.Info("m2", "field", "2") }, want: []map[string]any{{ "name": "m1", "data": map[string]any{ "with_a": "a", "with_b": "b", "field": "1", }, }, { "name": "m2", "data": map[string]any{ "with_a": "a", "with_b": "b", "field": "2", }, }}, }} { var out bytes.Buffer opts := HandlerOptions{ Level: slog.LevelDebug, NewTrace: func(TraceInfo) (io.WriteCloser, error) { return nopCloseWriter{&out}, nil }, } h, err := newJSONTraceHandler(opts, []slog.Attr{ slog.String("group_id", "group"), slog.Group("vantage_point", slog.String("type", "client"), ), }) if err != nil { t.Fatal(err) } log := slog.New(h) test.f(log) got := []map[string]any{} for i, e := range bytes.Split(out.Bytes(), []byte{0x1e}) { // i==0: empty string before the initial record separator // i==1: trace header; not part of this test if i < 2 { continue } var val map[string]any if err := json.Unmarshal(e, &val); err != nil { panic(fmt.Errorf("log unmarshal failure: %v\n%q", err, string(e))) } delete(val, "time") got = append(got, val) } if !reflect.DeepEqual(got, test.want) { t.Errorf("event mismatch\ngot: %v\nwant: %v", got, test.want) } } } type nopCloseWriter struct { io.Writer } func (nopCloseWriter) Close() error { return nil }	3.05 KB	2025-05-25 12:27

Terminal