Class ::nsmcp::LogDiscovery (public)

 ::nx::Class ::nsmcp::LogDiscovery

Defined in /usr/local/ns/tcl/nsmcp/log-discovery.tcl

Testcases:

No testcase defined.

Source code:

    :property {systemLog {}}
    :property {accessLog {}}
    :property {cacheDirectory {}}

    :method runtimeSystemLog {} {
        return [ns_info log]
    }

    :method runtimeAccessLog {} {
        if {[info commands ns_accesslog] eq ""} {
            return {}
        }
        return [ns_accesslog file]
    }

    :method runtimeAccessLogs {} {
        # Each loaded nslog instance publishes its effective path in its trace.
        set paths {}
        foreach trace [ns_server traces] {
            if {[lrange $trace 0 1] eq {trace nslog:conntrace}
                && [llength $trace] == 3 && [file pathtype [lindex $trace 2]] eq "absolute"} {
                lappend paths [lindex $trace 2]
            }
        }
        return $paths
    }

    :method describePath {path origin} {
        if {$path eq ""} {
            return [dict create path {} origin $origin exists false readable false]
        }
        if {[file pathtype $path] ne "absolute"} {
            error "log discovery requires an absolute effective path"
        }
        set path [file normalize $path]
        return [dict create path $path origin $origin exists [file isfile $path]  readable [expr {[file isfile $path] && [file readable $path]}]]
    }

    :public method discover {} {
        #
        # Resolve the effective system-log and access-log sources.
        #
        # Combine configured overrides with runtime discovery and retain
        # availability and origin metadata.
        #
        # @return The discovered log-source dictionary.
        #

        set system ${:systemLog}
        set systemOrigin override
        if {$system eq ""} {
            set system [:runtimeSystemLog]
            set systemOrigin runtime
        }
        set access ${:accessLog}
        set accessOrigin override
        if {$access eq ""} {
            set access [:runtimeAccessLog]
            set accessOrigin runtime
        }
        set primary [:describePath $access $accessOrigin]
        set sources {}
        if {$access ne ""} {
            dict set sources [dict get $primary path] $primary
        }
        foreach path [:runtimeAccessLogs] {
            set source [:describePath $path runtime]
            set path [dict get $source path]
            if {![dict exists $sources $path]} {
                dict set sources $path $source
            }
        }
        set cache ${:cacheDirectory}
        if {$cache eq ""} {
            set serverKey [string range [ns_crypto::md string -digest sha256 -- [ns_info server]] 0 11]
            set cache [file join /tmp nsmcp-cache-[pid]-$serverKey]
        }
        if {[file pathtype $cache] ne "absolute"} {
            error "cacheDirectory must be absolute"
        }
        return [dict create server [ns_info server]  system [:describePath $system $systemOrigin]  access $primary accessSources [dict values $sources]  cacheDirectory [file normalize $cache]]
    }

    :public method createCorrelation {name} {
        #
        # Create a named correlation service for the discovered sources.
        #
        # Validate the object name and source availability, then create the searches
        # owned by the correlation object; clean up on failure.
        #
        # @param name Name of the configured or registered item to resolve.
        #
        # @return The newly created correlation object command.
        #

        if {![string match ::* $name]} {
            error "expected a fully qualified object name"
        }
        if {[nsf::object::exists $name]} {
            error "object already exists: $name"
        }
        set discovered [:discover]
        if {![dict get $discovered system readable]} {
            error "discovered system log is missing or unreadable"
        }
        set access [dict get $discovered access path]
        if {$access ne "" && ![dict get $discovered access readable]} {
            error "discovered access log is missing or unreadable"
        }
        set searches {}
        set index 0
        foreach source [dict get $discovered accessSources] {
            if {![dict get $source readable]} {
                continue
            }
            incr index
            set search ${name}::access
            if {$index>1} {
                append search $index
            }
            dict set searches $search [dict get $source path]
        }
        ::nsmcp::LogCorrelation create $name -systemSearch ${name}::system -accessSearches [dict keys $searches]
        try {
            set common [list -store nsmcp:discovered-logs:[ns_info server]  -cacheDirectory [dict get $discovered cacheDirectory]]
            ::nsmcp::CachedLogSearch create ${name}::system  -path [dict get $discovered system path] {*}$common
            dict for {search path} $searches {
                ::nsmcp::CachedLogSearch create $search -path $path {*}$common
            }
        } on error {message options} {
            $name destroy
            return -options $options $message
        }
        return $name
    }

XQL Not present:

Generic, PostgreSQL, Oracle