Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/datalust/seqcli below:

datalust/seqcli: The Seq command-line client. Administer, log, ingest, search, from any OS.

The Seq client command-line app. Supports logging (seqcli log), searching (search), tailing (tail), querying (query) and JSON or plain-text log file ingestion (ingest), and much more.

The Seq installer for Windows includes seqcli. Otherwise, download the release for your operating system. Or, if you have dotnet installed, seqcli can be installed as a global tool using:

dotnet tool install --global seqcli

To set a default server URL and API key, run:

seqcli config set -k connection.serverUrl -v https://your-seq-server
seqcli config set -k connection.apiKey -v your-api-key

The API key will be stored in your SeqCli.json configuration file; on Windows, this is encrypted using DPAPI; on Mac/Linux the key is stored in plain text unless an encryptor is defined in encryption.encryptor. As an alternative to storing the API key in configuration, it can be passed to each command via the --apikey= argument.

seqcli is also available as a Docker container under datalust/seqcli:

docker run --rm datalust/seqcli:latest <command> [<args>]

To connect to Seq in a docker container on the local machine use the machine's IP address (not localhost) or specify docker host networking with --net host.

Use Docker networks and volumes to make local files and other containers accessible to seqcli within its container.

Each setting value can be overridden at runtime by specifying an environment variable of the form SEQCLI_<setting path>, where contains one element for each dotted segment of the setting name, separated by underscores.

For example the setting connection.serverUrl can overridden with the SEQCLI_CONNECTION_SERVERURL variable.

If you're automating Seq setup, chances are you won't have an API key yet for seqcli to use. During the initial Seq server configuration, you can specify firstRun.adminUsername and firstRun.adminPasswordHash (or the equivalent environment variables SEQ_FIRSTRUN_ADMINUSERNAME and SEQ_FIRSTRUN_ADMINPASSWORDHASH) to set an initial username and password for the administrator account. You can use these to create an API key, and then use the API key token with the remaining seqcli commands.

The seqcli apikey create command accepts --connect-username and --connect-password-stdin, and prints the new API key token to STDOUT (PowerShell syntax is used below):

$user = "admin"
$pw = "thepassword"
$token = (
  echo $pw |
  seqcli apikey create `
    -t CLI `
    --permissions="Read,Write,Project,Organization,System" `
    --connect-username $user --connect-password-stdin
)

See CONTRIBUTING.md.

When connecting with an API key the allowed operations are determined by the permissions assigned to that API key.

To determine the permission required for a command check the 'Permission demand' column of the equivalent server API operation. For example, the command apikey create uses the POST api/apikeys endpoint, which requires the Write permission.

All seqcli commands follow the same pattern:

seqcli <command> [<args>]

The complete list of supported commands can be viewed by running:

To show usage information for a specific command, run seqcli help <command>, for example:

seqcli help apikey create

This also works for command groups; to list all apikey sub-commands, run:

Available commands:

• apikey
  • apikey create — Create an API key for automation or ingestion.
  • apikey list — List available API keys.
  • apikey remove — Remove an API key from the server.
  • apikey update — Update an existing API key.
• app
  • app define — Generate an app definition for a .NET [SeqApp] plug-in.
  • app install — Install an app package.
  • app list — List installed app packages.
  • app run — Host a .NET [SeqApp] plug-in.
  • app uninstall — Uninstall an app package.
  • app update — Update an installed app package.
• appinstance
  • appinstance create — Create an instance of an installed app.
  • appinstance list — List instances of installed apps.
  • appinstance remove — Remove an app instance from the server.
  • appinstance update — Update an existing app instance.
• bench — Measure query performance.
• cluster health — Probe a Seq node's /health/cluster endpoint, and print the returned status. This command can also be used to wait on a timeout until the cluster is healthy..
• config
  • config clear — Clear fields in the SeqCli.json file.
  • config get — View a field from the SeqCli.json file.
  • config list — View all fields in the SeqCli.json file.
  • config set — Set a field in the SeqCli.json file.
• dashboard
  • dashboard list — List dashboards.
  • dashboard remove — Remove a dashboard from the server.
  • dashboard render — Produce a CSV or JSON result set from a dashboard chart.
• diagnostics ingestionlog — Retrieve the ingestion log.
• expressionindex
  • expressionindex create — Create an expression index.
  • expressionindex list — List expression indexes.
  • expressionindex remove — Remove an expression index from the server.
• feed
  • feed create — Create a NuGet feed.
  • feed list — List NuGet feeds.
  • feed remove — Remove a NuGet feed from the server.
  • feed update — Update an existing NuGet feed.
• forwarder
  • forwarder install — Install the forwarder as a Windows service.
  • forwarder restart — Restart the forwarder Windows service.
  • forwarder run — Listen on an HTTP endpoint and forward ingested logs to Seq.
  • forwarder start — Start the forwarder Windows service.
  • forwarder status — Show the status of the forwarder Windows service.
  • forwarder stop — Stop the forwarder Windows service.
  • forwarder truncate — Empty the forwarder's persistent log buffer.
  • forwarder uninstall — Uninstall the forwarder Windows service.
• help — Show information about available commands.
• index
  • index list — List indexes.
  • index suppress — Suppress an index.
• ingest — Send log events from a file or STDIN.
• license
  • license apply — Apply a license to the Seq server.
  • license show — Shows license applied to the Seq server.
• log — Send a structured log event to the server.
• node
  • node health — Probe a Seq node's /health endpoint, and print the returned HTTP status code, or 'Unreachable' if the endpoint could not be queried; note that no API key is required.
  • node list — List nodes in the Seq cluster.
• print — Pretty-print events in CLEF/JSON format, from a file or STDIN.
• profile
  • profile create — Create or replace a connection profile.
  • profile list — List connection profiles.
  • profile remove — Remove a connection profile.
• query — Execute an SQL query and receive results in CSV format.
• retention
  • retention create — Create a retention policy.
  • retention list — List retention policies.
  • retention remove — Remove a retention policy from the server.
  • retention update — Update an existing retention policy.
• sample
  • sample ingest — Log sample events into a Seq instance.
  • sample setup — Configure a Seq instance with sample dashboards, signals, users, and so on.
• search — Retrieve log events that match a given filter.
• setting
  • setting clear — Clear a runtime-configurable server setting.
  • setting names — Print the names of all supported settings.
  • setting set — Change a runtime-configurable server setting.
  • setting show — Print the current value of a runtime-configurable server setting.
• signal
  • signal create — Create a signal.
  • signal import — Import signals in newline-delimited JSON format.
  • signal list — List available signals.
  • signal remove — Remove a signal from the server.
  • signal update — Update an existing signal.
• tail — Stream log events matching a filter.
• template
  • template export — Export entities into template files.
  • template import — Import entities from template files.
• user
  • user create — Create a user.
  • user list — List users.
  • user remove — Remove a user from the server.
  • user update — Update an existing user.
• version — Print the current executable version.
• workspace
  • workspace create — Create a workspace.
  • workspace list — List available workspaces.
  • workspace remove — Remove a workspace from the server.
  • workspace update — Update an existing workspace.

Create an API key for automation or ingestion.

Example:

seqcli apikey create -t 'Test API Key' -p Environment=Test

List available API keys.

Example:

Remove an API key from the server.

Example:

seqcli apikey remove -t 'Test API Key'

Update an existing API key.

Example:

seqcli apikey update --json '{...}'

Generate an app definition for a .NET [SeqApp] plug-in.

Example:

seqcli app define -d "./bin/Debug/netstandard2.2"

Install an app package.

Example:

seqcli app install --package-id 'Seq.App.JsonArchive'

List installed app packages.

Example:

Host a .NET [SeqApp] plug-in.

Example:

seqcli tail --json | seqcli app run -d "./bin/Debug/netstandard2.2" -p ToAddress=example@example.com

Uninstall an app package.

Example:

seqcli app uninstall --package-id 'Seq.App.JsonArchive'

Update an installed app package.

Example:

seqcli app update -n 'HTML Email'

Create an instance of an installed app.

Example:

seqcli appinstance create -t 'Email Ops' --app hostedapp-314159 -p To=ops@example.com

List instances of installed apps.

Example:

Remove an app instance from the server.

Example:

seqcli appinstance remove -t 'Email Ops'

Update an existing app instance.

Example:

seqcli appinstance update --json '{...}'

Measure query performance.

Probe a Seq node's /health/cluster endpoint, and print the returned status. This command can also be used to wait on a timeout until the cluster is healthy..

Example:

seqcli cluster health -s https://seq.example.com --wait-until-healthy

Clear fields in the SeqCli.json file.

View a field from the SeqCli.json file.

View all fields in the SeqCli.json file.

Set a field in the SeqCli.json file.

List dashboards.

Example:

Remove a dashboard from the server.

Example:

seqcli dashboard remove -i dashboard-159

Produce a CSV or JSON result set from a dashboard chart.

Example:

seqcli dashboard render -i dashboard-159 -c 'Response Time (ms)' --last 7d --by 1h

Retrieve the ingestion log.

Example:

seqcli diagnostics ingestionlog

Create an expression index.

Example:

seqcli expressionindex create --expression "ServerName"

List expression indexes.

Example:

seqcli expressionindex list

Remove an expression index from the server.

Example:

seqcli expressionindex -i expressionindex-2529

Create a NuGet feed.

Example:

seqcli feed create -n 'CI' --location="https://f.feedz.io/example/ci" -u Seq --password-stdin

List NuGet feeds.

Example:

Remove a NuGet feed from the server.

Example:

Update an existing NuGet feed.

Example:

seqcli feed update --json '{...}'

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Install the forwarder as a Windows service.

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Restart the forwarder Windows service.

Preview command: only available when the --pre command-line flag is specified.

Listen on an HTTP endpoint and forward ingested logs to Seq.

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Start the forwarder Windows service.

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Show the status of the forwarder Windows service.

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Stop the forwarder Windows service.

Preview command: only available when the --pre command-line flag is specified.

Empty the forwarder's persistent log buffer.

Preview command: only available when the --pre command-line flag is specified. This command is supported on Windows platforms only.

Uninstall the forwarder Windows service.

Show information about available commands.

Example:

List indexes.

Example:

Suppress an index.

Example:

seqcli index suppress -i index-2191448f1d9b4f22bd32c6edef752748

Send log events from a file or STDIN.

Example:

seqcli ingest -i log-*.txt --json --filter="@Level <> 'Debug'" -p Environment=Test

Apply a license to the Seq server.

Example:

seqcli license apply --certificate="license.txt"

Shows license applied to the Seq server.

Example:

Send a structured log event to the server.

Example:

seqcli log -m 'Hello, {Name}!' -p Name=World -p App=Test

Probe a Seq node's /health endpoint, and print the returned HTTP status code, or 'Unreachable' if the endpoint could not be queried; note that no API key is required.

Example:

seqcli node health -s https://seq-2.example.com

List nodes in the Seq cluster.

Example:

Pretty-print events in CLEF/JSON format, from a file or STDIN.

Example:

seqcli print -i log-20201028.clef

Create or replace a connection profile.

Example:

seqcli profile create -n Production -s https://seq.example.com -a th15ISanAPIk3y

List connection profiles.

Example:

Remove a connection profile.

Example:

seqcli profile remove -n Production

Execute an SQL query and receive results in CSV format.

Example:

seqcli query -q "select count(*) from stream group by @Level" --start="2018-02-28T13:00Z"

Create a retention policy.

Example:

seqcli retention create --after 30d --delete-all-events

List retention policies.

Example:

Remove a retention policy from the server.

Example:

seqcli retention remove -i retentionpolicy-17

Update an existing retention policy.

Example:

seqcli retention update --json '{...}'

Log sample events into a Seq instance.

Example:

Configure a Seq instance with sample dashboards, signals, users, and so on.

Example:

Retrieve log events that match a given filter.

Example:

seqcli search -f "@Exception like '%TimeoutException%'" -c 30

Clear a runtime-configurable server setting.

Print the names of all supported settings.

Change a runtime-configurable server setting.

Print the current value of a runtime-configurable server setting.

Create a signal.

Example:

seqcli signal create -t 'Exceptions' -f "@Exception is not null"

Import signals in newline-delimited JSON format.

Example:

seqcli signal import -i ./Exceptions.json

List available signals.

Example:

Remove a signal from the server.

Example:

seqcli signal remove -t 'Test Signal'

Update an existing signal.

Example:

seqcli signal update --json '{...}'

Stream log events matching a filter.

Export entities into template files.

Example:

seqcli template export -o ./Templates

Import entities from template files.

Example:

seqcli template import -i ./Templates

Create a user.

Example:

seqcli user create -n alice -d 'Alice Example' -r 'User (read/write)' --password-stdin

List users.

Example:

Remove a user from the server.

Example:

seqcli user remove -n alice

Update an existing user.

Example:

seqcli user update --json '{...}'

Print the current executable version.

Create a workspace.

Example:

seqcli workspace create -t 'My Workspace' -c signal-314159 -c dashboard-628318

List available workspaces.

Example:

Remove a workspace from the server.

Example:

seqcli workspace remove -t 'My Workspace'

Update an existing workspace.

Example:

seqcli workspace update --json '{...}'

The seqcli ingest command can be used for parsing plain text logs into structured log events.

seqcli ingest -x "{@t:timestamp} [{@l:level}] {@m:*}{:n}{@x:*}"

The -x argument above is an extraction pattern that will parse events like:

2018-02-21 13:29:00.123 +10:00 [ERR] The operation failed
System.DivideByZeroException: Attempt to divide by zero
  at SomeClass.SomeMethod()

Extraction patterns have a simple high-level syntax:

• Text that appears in the pattern is matched literally - so a pattern like Hello, world! will match logging statements that are made up of this greeting only,
• Text between {curly braces} is a match expression that identifies a part of the event to be extracted, and
• Literal curly braces are escaped by doubling, so {{ will match the literal text {, and }} matches }.

Match expressions have the form:

Both the name and matcher are optional, but either one or the other must be specified. Hence {@t:timestamp} specifies a name of @t and value timestamp, {IPAddress} specifies a name only, and {:n} a value only (in this case the built-in newline matcher).

The name is the property name to be extracted; there are four built-in property names that get special handling:

• @t - the event's timestamp
• @m - the textual message associated with the event
• @l - the event's level
• @x - the exception or backtrace associated with the event

Other property names are attached to the event payload, so {Elapsed:dec} will extract a property called Elapsed, using the dec decimal matcher.

Match expressions with no name are consumed from the input, but are not added to the event payload.

Matchers identify chunks of the input event.

Different matchers are needed so that a piece of text like 200OK can be separated into separate properties, i.e. {StatusCode:nat}{Status:alpha}. Here, the nat (natural number) matcher also coerces the result into a numeric value, so that it is attached to the event payload numerically as 200 instead of as the text "200".

There are three kinds of matchers:

• Matchers like alpha and nat are built-in named matchers.
• The special matchers *, ** and so-on, are non-greedy content matchers; these will match any text up until the next pattern element matches (*), the next two elements match, and so-on. We saw this in action with the {@m:*}{:n} elements in the example - the message is all of the text up until the next newline.
• More complex compound matchers are described using a sub-expression. These are prefixed with an equals sign =, like {Phone:={:nat}-{:nat}-{:nat}}. This will extract chunks of text like 123-456-7890 into the Phone property.

Extraction patterns are processed from left to right. When the first non-matching pattern is encountered, extraction stops; any remaining text that couldn't be matched will be attached to the resulting event in an @unmatched property.

Multi-line events are handled by looking for lines that start with the first element of the extraction pattern to be used. This works well if the first line of each event begins with something unambiguous like an iso8601dt timestamp; if the lines begin with less specific syntax, the first few elements of the extraction pattern might be grouped to identify the start of events more accurately:

Here the literal text [, a timestamp token, adjacent space , level and closing ] are all grouped so that they constitute a single logical pattern element to identify the start of events.

When logs are streamed into seqcli ingest in real time, a 10 ms deadline is applied, within which any trailing lines that make up the event must be received.

journalctl -f -n 0 |
  seqcli ingest -x "{@t:syslogdt} {host} {ident:*}: {@m:*}{:n}" --invalid-data=ignore

tail -c 0 -F /var/log/syslog |
  seqcli ingest -x "{@t:syslogdt} {host} {ident:*}: {@m:*}{:n}"

This example ingests log files in the format:

#Fields: date time s-ip cs-method cs-uri-stem cs-uri-query s-port cs-username c-ip cs(User-Agent) 
cs(Referer) sc-status sc-substatus sc-win32-status sc-bytes cs-bytes time-taken

The extraction pattern is wrapped in the example for display purposes, and must appear all in one string argument when invoked.

seqcli ingest -i http.log --invalid-data=ignore -x "{@t:w3cdt} {ServerIP} {@m:={Method} {RequestPath}} 
{Query} {Port:nat} {Username} {ClientIP} {UserAgent} {Referer} {StatusCode:nat} {Substatus:nat} 
{Win32Status:nat} {ResponseBytes:nat} {RequestBytes:nat} {Elapsed}{:n}"

A nested {@m:= pattern is used to collect a substring of the log line for display as the event's message.

The seqcli * update family of commands make it possible to perform arbitrary updates to many complex entity types.

The update commands, like seqcli signal update shown in the example below, receive an updated JSON representation of an entity via STDIN.

This works particularly well with tools like jq and modern shells with native JSON support, such as PowerShell:

PS > $warnings = (seqcli signal list -i signal-m33302 --json | ConvertFrom-Json)

PS > $warnings.Title                                                                                                                
Warnings

PS > $warnings.Title = "Alarms"

PS > (echo $warnings | ConvertTo-Json) | seqcli signal update --json-stdin        

PS > seqcli signal list -i signal-m33302 --json                                 
{"Title": "Alarms", "Description": "Automatically created", "Filters": [{"De...

The seqcli forwarder family of commands provide simple, durable ingestion buffering for occasionally-connected and intermittently-disconnected systems. The forwarder implements the Seq ingestion API, so applications that write directly to Seq can instead write to the forwarder, which will persist data locally until it can be sent to the destination Seq server.

Note

Forwarder is designed for local use in isolated environments — for example, locally on a firewalled machine, or within a secured container network.

The forwarder HTTP API does not authenticate incoming requests. By default, only the ingestion endpoint is exposed, but if you opt into additional APIs such as the ingestion log, ensure the API is not reachable externally. Even in the default configuration, be aware that clients may trigger disk space exhaustion and other issues by sending excessive or maliciously-crafted ingestion traffic.

To start a forwarder instance at the terminal, listening on port 5341 and forwarding to seq.example.com, run:

seqcli forwarder run --pre --listen http://127.0.0.1:5341 -s https://seq.example.com

While the forwarder command group is in preview, all forwarder commands require the --pre switch; you'll also need to supply --pre when requesting help, e.g. seqcli help forwarder run --pre.

You can test your forwarder using the seqcli log command:

seqcli log -m Test -s http://127.0.0.1:5341

If forwarding is successful, the event will appear in the target Seq instance within a few seconds. If it isn't, and seqcli log didn't report an error, run through these troubleshooting steps:

1. Read the output of the seqcli forwarder run command: are the paths and URLs in there the ones you expect?
2. Check the destination Seq server's ingestion log; if the payload is being rejected by Seq, its likely you need to configure an API key for the forwarder's outbound connections, or API key forwarding (see below).
3. Check the forwarder's log file; this will be in the SeqCli/Logs subdirectory of the forwarder's storage path, which will be your user's home directory unless you overrode it with --storage or SEQCLI_STORAGE_PATH.
4. Enable the forwarder's ingestion log temporarily, ensuring this isn't accessible to untrusted callers.

The ingestion log records ingestion issues in a short in-memory buffer, so repetitive ingestion issues don't chew up disk space. The ingestion log may contain fragments of event data so it's not enabled by default; you can turn it on with:

SEQCLI_FORWARDER_DIAGNOSTICS_EXPOSEINGESTIONLOG=True seqcli forwarder run <other args>

The log can be retrieved by pointing seqcli at the forwarder:

seqcli diagnostics ingestionlog -s http://127.0.0.1:5341

If the ingestion log contains relevant entries but doesn't include enough information to track down the issue, you can opt in to showing even more information with SEQCLI_FORWARDER_DIAGNOSTICS_INGESTIONLOGSHOWDETAIL=True.

The forwarder reads its configuration from the environment and the SeqCli.json file. Run seqcli config to view all of the supported forwarder.* (SEQCLI_FORWARDER_*) settings.

Locally buffered events are stored in the SeqCli/Buffer subdirectory of the directory containing SeqCli.json. By default, this will be your user account's home folder.

To change the location of the SeqCli.json config file and local buffers, specify the --storage argument or set the SEQCLI_STORAGE_PATH environment variable when configuring and running the forwarder.

When connecting to Seq, seqcli forwarder will ignore any API keys attached to incoming payloads, and instead use the server URL and API key stored in SeqCli.json, in the SEQCLI_CONNECTION_* environment variables, or passed on the forwarder run command line.

To use the API keys from incoming payloads instead, set forwarder.useApiKeyForwarding or SEQCLI_FORWARDER_USEAPIKEYFORWARDING to True.

Warning

In order for durable buffering to work, seqcli forwarder needs to store the incoming API keys in its local buffer storage.

On Windows, these will be encrypted using machine-scoped DPAPI by default, and on other platforms they'll be saved as plain text. To perform encryption of stored API keys, supply shell scripts in the encryption.encryptor and encryption.decryptor (SEQCLI_ENCRYPTION_ENCRYPTOR and SEQCLI_ENCRYPTION_DECRYPTOR) configuration entries. The scripts will need to process data on STDIN and STDOUT: you can verify their effects by examining the api.key files stored in subdirectories of SeqCli/Buffer.

On Windows it's possible to install the forwarder as a service, using the seqcli forwarder install command. Pass a directory to make readable by the service in the --storage argument when installing the it. Make sure this directory is also passed in --storage when configuring the forwarder.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4