Class: PEClient::Resource::PuppetDB::QueryV4

Inherits:

Base

Object
Base
PEClient::Resource::PuppetDB::QueryV4

show all

Defined in:: lib/pe_client/resources/puppet_db/query.v4.rb,
lib/pe_client/resources/puppet_db/query.v4/nodes.rb,
lib/pe_client/resources/puppet_db/query.v4/reports.rb,
lib/pe_client/resources/puppet_db/query.v4/catalogs.rb,
lib/pe_client/resources/puppet_db/query.v4/factsets.rb

Overview

PuppetDB’s query API can retrieve data objects from PuppetDB for use in other applications.

See Also:

https://help.puppet.com/pdb/current/topics/api_query.htm

Defined Under Namespace

Classes: Catalogs, Factsets, Nodes, Reports

Constant Summary collapse

BASE_PATH = The base path for PuppetDB Query v4 endpoints.

"#{PuppetDB::BASE_PATH}/query/v4".freeze

Class Method Summary collapse

.query_paging(**kwargs) ⇒ Hash private

Most of PuppetDB’s query endpoints support a general set of HTTP URL parameters that can be used for paging results.

Instance Method Summary collapse

#aggregate_event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil) ⇒ Array<Hash>

The aggregate_event_counts endpoint is designated as experimental.
#catalogs ⇒ QueryV4::Catalogs
#edges(query: nil, **kwargs) ⇒ Hash⁺

Catalog edges are relationships formed between two resources.
#environments(environment: nil, type: nil, query: nil, **kwargs) ⇒ Hash⁺

Environments are semi-isolated groups of nodes managed by Puppet.
#event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil, **kwargs) ⇒ Hash⁺

The event_counts endpoint is designated as experimental.
#events(distinct_resources: nil, distinct_start_time: nil, distinct_end_time: nil, query: nil, **kwargs) ⇒ Hash⁺

Puppet agent nodes submit reports after their runs, and the Puppet Server forwards these to PuppetDB.
#fact_contents(query: nil, **kwargs) ⇒ Hash⁺

The fact_contents endpoint provides selective access to factset subtrees via fact paths.
#fact_names(query: nil, **kwargs) ⇒ Hash, Array<String>

The fact_names endpoint can be used to retrieve all known fact names.
#fact_paths(query: nil, **kwargs) ⇒ Hash, Array<String>

The fact_paths endpoint retrieves the set of all known fact paths for all known nodes, and is intended as a counterpart to the #fact_names endpoint, providing increased granularity around structured facts.
#facts(fact_name: nil, value: nil, query: nil, **kwargs) ⇒ Hash⁺

The facts endpoint provides access to a representation of node factsets where a result is returned for each top-level key in the node’s structured factset.
#factsets ⇒ QueryV4::Factsets
#inventory(query: nil, **kwargs) ⇒ Hash⁺

The inventory endpoint provides an alternate and potentially more efficient way to access structured facts as compared to the #facts, #fact_contents, and #factsets endpoints.
#nodes ⇒ QueryV4::Nodes
#package_inventory(certname: nil, query: nil, **kwargs) ⇒ Hash⁺

Returns all installed packages along with the certname of the nodes they are installed on or a specific node.
#packages(query: nil, **kwargs) ⇒ Hash⁺

Returns all installed packages, across all nodes.
#producers(producer: nil, type: nil, query: nil, **kwargs) ⇒ Hash⁺

Producers are the Puppet Servers that send reports, catalogs, and factsets to PuppetDB.
#reports ⇒ QueryV4::Reports
#resources(type: nil, title: nil, query: nil, **kwargs) ⇒ Hash⁺

You can query resources by making an HTTP request to the resources endpoint.
#root(query:, timeout: nil, ast_only: nil, origin: nil, explain: nil, **kwargs) ⇒ Hash⁺

The root query endpoint can be used to retrieve any known entities from a single endpoint.

Methods inherited from Base

#initialize

Constructor Details

This class inherits a constructor from PEClient::Resource::Base

Class Method Details

.query_paging(**kwargs) ⇒ `Hash`

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Most of PuppetDB’s query endpoints support a general set of HTTP URL parameters that can be used for paging results. PuppetDB also supports paging via query operators, as described in the AST documentation.

Parameters:

kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 363

def self.query_paging(**kwargs)
  {
    order_by: kwargs[:order_by],
    limit: kwargs[:limit],
    include_total: kwargs[:include_total],
    offset: kwargs[:offset]
  }
end

Instance Method Details

#aggregate_event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil) ⇒ `Array<Hash>`

The aggregate_event_counts endpoint is designated as experimental. It may be altered or removed in a future release. Puppet agent nodes submit reports after their runs, and the Puppet Server forwards these to PuppetDB. Each report includes:

Data about the entire run.
Metadata about the report.
Many events, describing what happened during the run.

After this information is stored in PuppetDB, it can be queried in various ways.

You can query data about the run and report metadata by making an HTTP request to the #reports endpoint.
You can query data about individual events by making an HTTP request to the #events endpoint.
You can query summaries of event data by making an HTTP request to the #event_counts or #aggregate_event_counts endpoints.

Parameters:

summarize_by (String) —

A string specifying which type of object you’d like to see counts for. Supported values are “resource”, “containing_class”, and “certname”.
count_by (String) (defaults to: nil) —

A string specifying what type of object is counted when building up the counts of successes, failures, noops, and skips. Supported values are “resource” (default) and “certname”.
counts_filter (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
distinct_resources (Boolean) (defaults to: nil) —

This parameter is passed along to the #events endpoint.
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).

Returns:

(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/aggregate-event-counts.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 305

def aggregate_event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil)
  @client.get "#{BASE_PATH}/aggregate-event-counts",
    params: {summarize_by:, count_by:, counts_filter: counts_filter&.to_json, distinct_resources:, query: query&.to_json}.compact
end

#catalogs ⇒ `QueryV4::Catalogs`

Returns:

(QueryV4::Catalogs)

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 350

def catalogs
  require_relative "query.v4/catalogs"
  @catalogs ||= QueryV4::Catalogs.new(@client)
end

#edges(query: nil, **kwargs) ⇒ `Hash`⁺

Catalog edges are relationships formed between two resources. They represent the edges inside the catalog graph, whereas resources represent the nodes in the graph. You can query edges by making a request to the edges endpoint.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/edges.htm



222
223
224

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 222

def edges(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/edges", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#environments(environment: nil, type: nil, query: nil, **kwargs) ⇒ `Hash`⁺

Environments are semi-isolated groups of nodes managed by Puppet. Nodes are assigned to environments by their own configuration, or by the Puppet Server’s external node classifier. When PuppetDB collects info about a node, it keeps track of the environment the node is assigned to. PuppetDB also keeps a list of environments it has seen. You can query this list by making an HTTP request to the environments endpoint.

Parameters:

environment (String) (defaults to: nil) —

This will return the name of the environment if it currently exists in PuppetDB.
type (String) (defaults to: nil) —

“events”, “facts”, “reports”, or “resources”
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/environments.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 99

def environments(environment: nil, type: nil, query: nil, **kwargs)
  uri = "#{BASE_PATH}/environments"
  uri += "/#{environment}" if environment
  uri += "/#{type}" if environment && type
  @client.get uri, params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil, **kwargs) ⇒ `Hash`⁺

The event_counts endpoint is designated as experimental. It may be altered or removed in a future release. Puppet agent nodes submit reports after their runs, and the Puppet Server forwards these to PuppetDB. Each report includes:

Data about the entire run
Metadata about the report
Many events, describing what happened during the run

After this information is stored in PuppetDB, it can be queried in various ways.

You can query data about the run and report metadata by making an HTTP request to the #reports endpoint.
You can query data about individual events by making an HTTP request to the #events endpoint.
You can query summaries of event data by making an HTTP request to the #event_counts or #aggregate_event_counts endpoints.

Parameters:

summarize_by (String) —

A string specifying which type of object you’d like to see counts for. Supported values are “resource”, “containing_class”, and “certname”.
count_by (String) (defaults to: nil) —

A string specifying what type of object is counted when building up the counts of successes, failures, noops, and skips. Supported values are “resource” (default) and “certname”.
counts_filter (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
distinct_resources (Boolean) (defaults to: nil) —

This parameter is passed along to the #events endpoint.
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/event-counts.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 277

def event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil, **kwargs)
  @client.get "#{BASE_PATH}/event-counts",
    params: {summarize_by:, count_by:, counts_filter: counts_filter&.to_json, distinct_resources:, query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#events(distinct_resources: nil, distinct_start_time: nil, distinct_end_time: nil, query: nil, **kwargs) ⇒ `Hash`⁺

Puppet agent nodes submit reports after their runs, and the Puppet Server forwards these to PuppetDB. Each report includes:

Data about the entire run
Metadata about the report
Many events, describing what happened during the run

After this information is stored in PuppetDB, it can be queried in various ways.

You can query data about the run and report metadata by making an HTTP request to the #reports endpoint.
You can query data about individual events by making an HTTP request to the #events endpoint.
You can query summaries of event data by making an HTTP request to the #event_counts or #aggregate_event_counts endpoints.

Parameters:

distinct_resources (Boolean) (defaults to: nil) —

If specified, the result set will only return the most recent event for a given resource on a given node. (EXPERIMENTAL: it is possible that the behavior of this parameter may change in future releases.)
distinct_start_time (String) (defaults to: nil) —

An ISO 8601 timestamp. Required if distinct_resources is true.
distinct_end_time (String) (defaults to: nil) —

An ISO 8601 timestamp. Required if distinct_resources is true.
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/events.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 248

def events(distinct_resources: nil, distinct_start_time: nil, distinct_end_time: nil, query: nil, **kwargs)
  @client.get "#{BASE_PATH}/events",
    params: {distinct_resources:, distinct_start_time:, distinct_end_time:, query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#fact_contents(query: nil, **kwargs) ⇒ `Hash`⁺

The fact_contents endpoint provides selective access to factset subtrees via fact paths. Note that the #inventory endpoint will often provide more flexible and efficient access to the same information.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/fact-contents.htm



179
180
181

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 179

def fact_contents(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/fact-contents", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#fact_names(query: nil, **kwargs) ⇒ `Hash`, `Array<String>`

The fact_names endpoint can be used to retrieve all known fact names.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<String>)

See Also:

https://help.puppet.com/pdb/current/topics/fact-names.htm



153
154
155

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 153

def fact_names(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/fact-names", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#fact_paths(query: nil, **kwargs) ⇒ `Hash`, `Array<String>`

The fact_paths endpoint retrieves the set of all known fact paths for all known nodes, and is intended as a counterpart to the #fact_names endpoint, providing increased granularity around structured facts. The endpoint may be useful for building autocompletion in GUIs or for other applications that require a basic top-level view of fact paths.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<String>)

See Also:

https://help.puppet.com/pdb/current/topics/fact-paths.htm



166
167
168

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 166

def fact_paths(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/fact-paths", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#facts(fact_name: nil, value: nil, query: nil, **kwargs) ⇒ `Hash`⁺

The facts endpoint provides access to a representation of node factsets where a result is returned for each top-level key in the node’s structured factset. Note that the #inventory endpoint will often provide more flexible and efficient access to the same information.

Parameters:

fact_name (String) (defaults to: nil) —

This will return all facts with the given fact name, for all nodes.
value (String) (defaults to: nil) —

This will return all facts with the given fact name and value, for all nodes. (That is, only the certname field will differ in each result.)
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/facts.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 138

def facts(fact_name: nil, value: nil, query: nil, **kwargs)
  uri = "#{BASE_PATH}/facts"
  uri += "/#{fact_name}" if fact_name
  uri += "/#{value}" if fact_name && value
  @client.get uri, params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#factsets ⇒ `QueryV4::Factsets`

Returns:

(QueryV4::Factsets)

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 344

def factsets
  require_relative "query.v4/factsets"
  @factsets ||= QueryV4::Factsets.new(@client)
end

#inventory(query: nil, **kwargs) ⇒ `Hash`⁺

The inventory endpoint provides an alternate and potentially more efficient way to access structured facts as compared to the #facts, #fact_contents, and #factsets endpoints.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/inventory.htm



191
192
193

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 191

def inventory(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/inventory", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#nodes ⇒ `QueryV4::Nodes`

Returns:

(QueryV4::Nodes)

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 338

def nodes
  require_relative "query.v4/nodes"
  @nodes ||= QueryV4::Nodes.new(@client)
end

#package_inventory(certname: nil, query: nil, **kwargs) ⇒ `Hash`⁺

Returns all installed packages along with the certname of the nodes they are installed on or a specific node.

Parameters:

certname (String) (defaults to: nil)
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 332

def package_inventory(certname: nil, query: nil, **kwargs)
  @client.get certname ? "#{BASE_PATH}/package-inventory/#{certname}" : "#{BASE_PATH}/package-inventory",
    params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#packages(query: nil, **kwargs) ⇒ `Hash`⁺

Returns all installed packages, across all nodes.

Parameters:

query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/packages.htm#pdbqueryv4packages



318
319
320

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 318

def packages(query: nil, **kwargs)
  @client.get "#{BASE_PATH}/packages", params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#producers(producer: nil, type: nil, query: nil, **kwargs) ⇒ `Hash`⁺

Producers are the Puppet Servers that send reports, catalogs, and factsets to PuppetDB. When PuppetDB stores a report, catalog, or factset, it keeps track of the producer of the report/catalog/factset. PuppetDB also keeps a list of producers it has seen. You can query this list by making an HTTP request to the producers endpoint.

Parameters:

producer (String) (defaults to: nil) —

This will return the name of the producer if it currently exists in PuppetDB.
type (String) (defaults to: nil) —

“catalogs”, “factsets”, or “reports”
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>, Hash)

See Also:

https://help.puppet.com/pdb/current/topics/producers.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 119

def producers(producer: nil, type: nil, query: nil, **kwargs)
  uri = "#{BASE_PATH}/producers"
  uri += "/#{producer}" if producer
  uri += "/#{type}" if producer && type
  @client.get uri, params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#reports ⇒ `QueryV4::Reports`

Returns:

(QueryV4::Reports)

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 356

def reports
  require_relative "query.v4/reports"
  @reports ||= QueryV4::Reports.new(@client)
end

#resources(type: nil, title: nil, query: nil, **kwargs) ⇒ `Hash`⁺

You can query resources by making an HTTP request to the resources endpoint.

Parameters:

type (String) (defaults to: nil) —

This will return all resources for all nodes with the given type.
title (String) (defaults to: nil) —

This will return all resources for all nodes with the given type and title.
query (Array) (defaults to: nil) —

An Array of query predicates, in prefix notation ([“<OPERATOR>”, “<FIELD>”, “<VALUE>”]).
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/resources.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 205

def resources(type: nil, title: nil, query: nil, **kwargs)
  uri = "#{BASE_PATH}/resources"
  uri += "/#{type}" if type
  uri += "/#{URI.encode_www_form_component(title)}" if type && title
  @client.get uri, params: {query: query&.to_json}.merge!(QueryV4.query_paging(**kwargs)).compact
end

#root(query:, timeout: nil, ast_only: nil, origin: nil, explain: nil, **kwargs) ⇒ `Hash`⁺

The root query endpoint can be used to retrieve any known entities from a single endpoint.

Parameters:

query (String, Array) —

Either a PQL query string, or an AST JSON array containing the query in prefix notation ([“from”, “<ENTITY>”, [“<OPERATOR>”, “<FIELD>”, “<VALUE>”]]). Unlike other endpoints, a query with a from is required to choose the entity for which to query. For general info about queries, see our guide to query structure.
timeout (Integer) (defaults to: nil) —

An optional limit on the number of seconds that the query will be allowed to run (e.g. timeout=30). If the limit is reached, the query will be interrupted. At the moment, that will result in either a 500 HTTP response status, or (more likely) a truncated JSON result if the result has begun streaming. Specifying this parameter is strongly encouraged. Lingering queries can consume substantial server resources (particularly on the PostgreSQL server) decreasing performance, for example, and increasing the maximum required storage space. The query timeout configuration settings are also recommended.
ast_only (Boolean) (defaults to: nil) —

When true, the query response will be the supplied query in AST, either exactly as supplied or translated from PQL. False by default.
origin (String) (defaults to: nil) —

A string describing the source of the query. It can be anything, and will be reported in the log when PuppetDB is configured to log queries. Note that Puppet intends to use origin names beginning with puppet: for its own queries, so it is recommended that other clients choose something else.
explain (String) (defaults to: nil) —

The string value “analyze”. This parameter can be used to tell PuppetDB to return the execution plan of a statement instead of the query results. The execution plan shows how the table(s) referenced by the statement will be scanned, the estimated statement execution cost and the actual run time statistics.
kwargs (Hash) —

Keyword arguments for paging

Options Hash (**kwargs):

:order_by (String) —

This parameter can be used to ask PuppetDB to return results sorted by one or more fields, in ascending or descending order. The value must be an Array of Hashes. Each map represents a field to sort by, and the order in which the maps are specified in the array determines the sort order. Each map must contain the key field, whose value must be the name of a field that can be returned by the specified query. Each map may also optionally contain the key order, whose value may either be “asc” or “desc”, depending on whether you wish the field to be sorted in ascending or descending order. The default value for this key, if not specified, is “asc”. Note that the legal values for field vary depending on which endpoint you are querying. For lists of legal fields, please refer to the documentation for the specific query endpoints.
:limit (Integer) —

This parameter can be used to restrict the result set to a maximum number of results.
:include_total (Boolean) —

This parameter lets you request a count of how many records would have been returned, had the query not been limited using the limit parameter. This is useful if you want your application to show how far the user has navigated (“page 3 of 15”). The value should be a Boolean, and defaults to false. If true, the HTTP response will contain a header X-Records, whose value is an integer indicating the total number of results available. Note: Setting this flag to true can decrease performance.
:offset (Integer) —

This parameter can be used to tell PuppetDB to return results beginning at the specified offset. For example, if you’d like to page through query results with a page size of 10, your first query would specify ‘limit: 10` and `offset: 0`, your second query would specify `limit: 10` and `offset: 10`, and so on. Note that the order in which results are returned by PuppetDB is not guaranteed to be consistent unless you specify a value for :order_by, so this parameter should generally be used in conjunction with :order_by.

Returns:

(Hash)
(Array<Hash>)

See Also:

https://help.puppet.com/pdb/current/topics/root_endpoint.htm

# File 'lib/pe_client/resources/puppet_db/query.v4.rb', line 80

def root(query:, timeout: nil, ast_only: nil, origin: nil, explain: nil, **kwargs)
  query = query.to_json if query.is_a?(Array)
  @client.get BASE_PATH, params: {query: query, timeout:, ast_only:, origin:, explain:}.merge!(QueryV4.query_paging(**kwargs)).compact
end

Class: PEClient::Resource::PuppetDB::QueryV4

Overview

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

Constructor Details

Class Method Details

.query_paging(**kwargs) ⇒ Hash

Instance Method Details

#aggregate_event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil) ⇒ Array<Hash>

#catalogs ⇒ QueryV4::Catalogs

#edges(query: nil, **kwargs) ⇒ Hash+

#environments(environment: nil, type: nil, query: nil, **kwargs) ⇒ Hash+

#event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil, **kwargs) ⇒ Hash+

#events(distinct_resources: nil, distinct_start_time: nil, distinct_end_time: nil, query: nil, **kwargs) ⇒ Hash+

#fact_contents(query: nil, **kwargs) ⇒ Hash+

#fact_names(query: nil, **kwargs) ⇒ Hash, Array<String>

#fact_paths(query: nil, **kwargs) ⇒ Hash, Array<String>

#facts(fact_name: nil, value: nil, query: nil, **kwargs) ⇒ Hash+

#factsets ⇒ QueryV4::Factsets

#inventory(query: nil, **kwargs) ⇒ Hash+

#nodes ⇒ QueryV4::Nodes

#package_inventory(certname: nil, query: nil, **kwargs) ⇒ Hash+

#packages(query: nil, **kwargs) ⇒ Hash+

#producers(producer: nil, type: nil, query: nil, **kwargs) ⇒ Hash+

#reports ⇒ QueryV4::Reports

#resources(type: nil, title: nil, query: nil, **kwargs) ⇒ Hash+

#root(query:, timeout: nil, ast_only: nil, origin: nil, explain: nil, **kwargs) ⇒ Hash+

.query_paging(**kwargs) ⇒ `Hash`

#aggregate_event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil) ⇒ `Array<Hash>`

#catalogs ⇒ `QueryV4::Catalogs`

#edges(query: nil, **kwargs) ⇒ `Hash`⁺

#environments(environment: nil, type: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#event_counts(summarize_by:, count_by: nil, counts_filter: nil, distinct_resources: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#events(distinct_resources: nil, distinct_start_time: nil, distinct_end_time: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#fact_contents(query: nil, **kwargs) ⇒ `Hash`⁺

#fact_names(query: nil, **kwargs) ⇒ `Hash`, `Array<String>`

#fact_paths(query: nil, **kwargs) ⇒ `Hash`, `Array<String>`

#facts(fact_name: nil, value: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#factsets ⇒ `QueryV4::Factsets`

#inventory(query: nil, **kwargs) ⇒ `Hash`⁺

#nodes ⇒ `QueryV4::Nodes`

#package_inventory(certname: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#packages(query: nil, **kwargs) ⇒ `Hash`⁺

#producers(producer: nil, type: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#reports ⇒ `QueryV4::Reports`

#resources(type: nil, title: nil, query: nil, **kwargs) ⇒ `Hash`⁺

#root(query:, timeout: nil, ast_only: nil, origin: nil, explain: nil, **kwargs) ⇒ `Hash`⁺