The official Polyseer.io SDK for Ruby. Detailed API information can be found at (https://polyseer.io/documentation).
Polyseer.io is an Integrated Development Platform that instantly provides teams with the resources needed to build, support, and maintain world class software products.
- Ruby
- gem
To install, run:
gem install polyseerio
To add to your project Gemfile, insert:
gem 'polyseerio'
Be sure to check out the examples in /example.
Certain values can be set in environment variables:
- POLYSEERIO_TOKEN access-token used for API calls
- RAILS_ENV the current environment
- POLYSEERIO_LOG_LEVEL SDK logging level
The SDK provides an agent that allows for immediate integration as well as direct platform interactions.
Example: (Quick start)
include 'polyseerio'
client = Polyseerio.start
client.instance.fact('foo', 'bar').execute.value
Example: (SDK)
include 'polyseerio'
client = Polyseerio.make
client.Event.create(name: 'Testing').execute.value
All Polyseer.io SDK's make use of Promises for async calls. Promises allow for delaying and chaining async work.
- Provides direct platform calls as well as a Polyseer.io Ruby agent.
- All client SDK calls return a Concurrent::Promise.
- Supports functional style programming.
- Supports object-oriented style programming.
- ORM style instances. E.g. environment.save(), alert.trigger();
- A resources environment can be deduced or explicitly passed to SDK calls through the options param.
- API calls made using the https:// protocol.
Be sure to check out the examples in /example.
Use of the SDK starts with the creation of a client. To construct a client instance, you may call either Polyseerio.start or Polyseerio.make. Once a client has been created you may use any of its resources.
- Polyseerio
- .
make(options = {}) ⇒ Polyseerio::Client
- Create a client.
options (Hash)
see Polyseerio.start options.:deduce (Boolean)
if the environment should be deduced when not supplied:env (String)
environment variable that holds the current environment:timeout (Integer)
integer containing number of ms to wait for server responses:token (String)
an api token:token_env (String)
if no token is provided, this environment variable will be checked:upsert_env (Boolean)
if an environment cannot be found it will be created:version (String)
api version to use
- .
start(options = {}) ⇒ Polyseerio::Client
- Create a client and start an Agent.
options (Hash)
:agent (Hash)
agent options (see client.start_agent options)
::Enum
::Color (Hash)
platform color values::Determiner (Hash)
expectation deteriner types::Direction (Hash)
instance direction types::Icon (Hash)
platform icon types::Protocol (Hash)
alert protocol types::Strategy (Hash)
instance attachment strategies::Subtype (Hash)
instance subtypes::Type (Hash)
resource types
- .
- client
.current_environment ⇒ client.Environment
- Resolves the current environment IF it has been deduced.
.start_agent(options = {}) ⇒ Polyseerio::Client
- Starts the Polyseer.io agent for this client.
options
.attach (Boolean)
.attach_strategy (Symbol)
.name (String)
instance name (will be used as a unique id).description (String)
a description of this instance.group (String)
what group this instance belongs to.direction (String)
the monitoring direction (inbound) // force this.subtype (Polyseerio::Enum::Subtype)
the instance subtype: periodic or long_running..expectation
will be upserted for this instance.is_alive (Boolean)
create an expectation that this process is alive
.fact
.engine (Boolean)
the current ruby engine.gid (Boolean)
the group if othe process is running under.launch_arguments (Boolean)
command used to launch the instance.pid (Boolean)
the id of the process.platform (Boolean)
the operating platform of.ruby_version (Boolean)
the version of ruby being used.uid (Boolean)
user id the process is running as
.metric
.cpu (Boolean)
track user and system cpu usage.memory (Boolean)
track memory usage.uptime (Boolean)
track process uptime
.event
.start (Boolean)
event notice when agent starts.stop (Boolean)
event notice when agent stops
.process_event
.exit (Boolean)
event notice on process exit
- .Alert
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.new(attributes = {}) ⇒ client.Alert
.remove()
.save()
.trigger(payload = {})
.remove(id, options = {})
.trigger(id, payload, options = {})
.update(id, updates, options = {})
- .Channel
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.message(id, content, options = {})
.new(attributes = {}) ⇒ client.Channel
.message(content)
.remove()
.save()
.remove(id, options = {})
.update(id, updates, options = {})
- .Environment
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.message(id, content, options = {})
.new(attributes = {}) ⇒ client.Environment
.message(content)
.remove()
.save()
.remove(id, options = {})
.update(id, payload = {}, options = {})
- .Event
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.new(attributes = {}) ⇒ client.Event
.save()
- .Expectation
.check(id, options = {})
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.new(attributes = {}) ⇒ client.Expectation
.check()
.remove()
.save()
.remove(id, options = {})
.update(id, updates, options = {})
- .Instance
.attach(options = {})
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.new(attributes = {}) ⇒ client.Instance
.add_fact(key, resolver)
- Add a fact to the attach monitoring loop.
key (symbol)
resolver (string|number|block)
.add_gauge(key, resolver)
- Add a gauge to the attach monitoring loop.
key (symbol)
resolver (string|number|block)
.attach()
- Start inbound monitoring.
.detach()
- Terminate inbound monitoring.
.fact(key, value)
- Send a one-off fact.
.gauge(key, value)
- Send a one-off gauge metric.
.remove()
.save()
.remove(id, options = {})
.update(id, updates, options = {})
- .LogicBlock
.create(attributes = {}, options = {})
.execute(id, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.find_by_name(name, options = {})
.new(attributes = {}) ⇒ client.LogicBlock
.execute()
.remove()
.save()
.remove(id, options = {})
.update(id, updates, options = {})
- .Member
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.new(attributes = {}) ⇒ client.Member
.remove()
.save()
.remove(id, options = {})
.update(id, updates, options = {})
- .Settings
.retrieve()
.update(updates, options = {})
- .Task
.create(attributes = {}, options = {})
.find(query = {}, options = {})
.find_by_id(id, options = {})
.new(attributes = {}) ⇒ client.Task
.remove()
.save()
.remove(id, options = {})
.update(id, updates = {}, options = {})
To test, build, and install locally:
make
To build and install:
make build
Testing requires:
- Make
Install gems locally by running:
make install
Then run a command below based on what test suite you need to run.
make lint
make unit-test
make integration-test
Requires the environment to have a root level access-token defined as:
export POLYSEERIO_TOKEN=a-test-root-key
make validation-test
make test
Set the environment variable POLYSEERIO_LOG_LEVEL to debug in order to get detailed logging information.