Environment Variables

Verify correctness of environment variables

Access environment variables. Also includes presence validation, type coercion and default values.

This allows you to set some nice default syslog configuration options for your rails environment, using syslog for all production and development environments, except your local development environment. Set the environment variable "RAILS_DEV" to "true" to not use sysloger.

EnvConfig is a tool for setting and syncing environment variables across your the servers in your cluster with a few simple Capistrano tasks. The library manipulates the system-wide environment variables by modifying the `/etc/environment` file.

A rack middleware that blocks all bots when BLOCK_ROBOTS environment variable is set to true.

Providing config values for your Ruby app with convenience methods like overwriting variables per Rails environment and overwriting variables with a local options_local.yml file.

Environment variables in the node file

HTTP server companion for Bone (remote environment variables)

rcloadenv is a tool for loading configuration from the Google Runtime Config API into environment variables. The rcloadenv ruby gem is a ruby implementation of the tool that may be installed as a ruby gem or included in a ruby Gemfile.

Environment variable handling for teams following 12 Factor/Heroku pattern

A tiered approach to configuration which allows for full control of your test suite through environment variables

Provides casting wrappers around fetch for environment variables.

EnvMem allows you to dump your GC.stat information from a long-running server, then produce a simple shellscript to set up your Ruby memory environment variables to match that configuration. This improves startup time slightly and allows you finer-grain control over your memory setup. If you've ever found Ruby memory environment variables on a web page and used them to try to speed up your app, this is a better approach.

A series of packages to help using Vlad to manage "enterprise" environments, includes host OS discovery and test-based per host variable settings, targeting of environments and sub-environments, mysql and xen management tasks. Currently consists of the following: * Vlad the Translator * Vlad the Environmentalist * Vlad the DBA * Vlad the Xen Master == FEATURES/PROBLEMS: * Management of heterogenious enironments, dynamic discovery and flexible handling of remote host types. * Support of multiple environments and subenvironments, multiple projects withing an environemnt

When you are developing a new feature if your app have some environments like test, staging and production is easy to forget an environment variable in the middle of the process. Also when you migrate the app to another server is easy to forget an environment variable.

Rack middleware to set ENVironment variables around your app.

A tool for painless parsing and validation of environment variables.

Creates a STRICT_ENV constant that you can query for environment variables and get meaningful exceptions

This gem provides an application, path_editor, which makes it easy to add, remove, display or clean up the Windows PATH environment variable.

Ruby gem to initialize Rails config.secret_token from an environment variable

CalliopeImport uses environment variables of a test run to make an API call with the test results. See the documentation for more information.

Storing configuration in the environment is one of the tenets of a twelve-factor app. However, problems arise when required environment variables aren't set.

Migr8.rb is a database schema version management tool. * Easy to install, easy to setup, and easy to start * No configuration file; instead, only two environment variables * Designed carefully to suit Git or Mercurial * Supports SQLite3, PostgreSQL, and MySQL * Written in Ruby (>= 1.8)

Inventory-Rake Inventory-Rake provides Rake¹ tasks for your Inventory². This includes tasks for cleaning up our project, compiling extensions, installing dependencies, installing and uninstalling the project itself, and creating and pushing distribution files to distribution points. ¹ See http://rake.rubyforge.org/ ² See http://disu.se/software/inventory-1.0/ § Installation Install Inventory-Rake with % gem install inventory-rake § Usage Include the following code in your ‹Rakefile›, where ‹Package› is the top-level module of your project: require 'inventory-rake-3.0' load File.expand_path('../lib/package/version.rb', __FILE__) Inventory::Rake::Tasks.define Package::Version Inventory::Rake::Tasks.unless_installing_dependencies do # Any additional tasks that your project’s dependencies provide end ‹Inventory::Rake::Tasks.define› does the heavy lifting. It takes our inventory and sets up the tasks mentioned above. We also do some additional customization of the gem specification. As we want to be able to use our Rakefile to install our dependencies for us, the rest of the Rakefile is inside the conditional #unless_installing_dependencies, which, as the name certainly implies, executes its block unless the task being run is the one that installs our dependencies. This becomes relevant if we want to, for example, set up Travis¹ integration. To do so, simply add before_script: - gem install inventory-rake -v '~> VERSION' --no-rdoc --no-ri - rake gem:deps:install to your ‹.travis.yml› file. This’ll make sure that Travis installs all development, runtime, and optional dependencies that you’ve listed in your inventory before running any tests. There’s more information in the {API documentation}² that you’ll likely want to read up on if anything is unclear. ¹ See http://travis-ci.org/ ² See http://disu.se/software/inventory-rake-1.0/api/Inventory/Rake/ § Tasks The tasks that are created if you use Inventory-Rake are: = check. = Check that the package meets its expectations. = mostlyclean. = Delete targets built by rake that are ofter rebuilt. = clean. = Delete targets built by rake; depends on mostlyclean. = distclean. = Delete all files not meant for distribution; depends on clean. = compile. = Compile all extensions; depends on each compile:name. = compile:name. = Compile extension /name/; depends on lib/path/so file. = lib/path/so. = Installed dynamic library of extension /name/ inside inventory path; depends on ext/name/so. = ext/name/so. = Dynamic library of extension /name/; depends on ext/name/Makefile and the source files of the extension. = ext/name/Makefile. = Makefile for extension /name/; depends on inventory path, ext/name/extconf.rb file, and ext/name/depend file. Will be created by extconf.rb, which may take options from environment variable name#upcase_EXTCONF_OPTIONS or ‹EXTCONF_OPTIONS› if defined. = clean:name. = Clean files built for extension /name/; depended upon by clean. = spec. = Create specifications; depends on gem:spec. = gem:spec. = Create gem specification; depends on gemspec. = gemspec (file). = Gem specification file; depends on Rakefile, README, and inventory path. = dist. = Create files for distribution; depends on gem:dist. = gem:dist. = Create gem for distribution; depends on inventory:check and gem file. = inventory:check. = Check that the inventory is correct by looking for files not listed in the inventory that match the pattern and for files listed in the inventory that don’t exist; depends on distclean. = gem (file). = Gem file; depends on files included in gem. = dist:check. = Check files before distribution; depends on dist and gem:dist:check. = gem:dist:check. = Check gem before distribution; depends on gem:dist. = deps:install. = Install dependencies on the local system; depends on gem:deps:install. = gem:deps:install. = Install dependencies in ruby gem directory. = deps:install:user. = Install dependencies for the current user; depends on gem:deps:install:user. = gem:deps:install:user. = Install dependencies in the user gem directory. = install. = Install distribution files on the local system; depends on gem:install. = gem:install. = Install gem in ruby gem directory; depends on gem:dist. = install:user. = Install distribution files for the current user; depends on gem:install:user. = gem:install:user. = Install gem in the user gem directory. = uninstall. = Delete all files installed on the local system. = gem:uninstall. = Uninstall gem from ruby gem directory. = uninstall:user. = Delete all files installed for current user. = gem:uninstall:user. = Uninstall gem from ruby gem directory. = push. = Push distribution files to distribution hubs. = gem:push. = Push gem to rubygems.org. § Financing Currently, most of my time is spent at my day job and in my rather busy private life. Please motivate me to spend time on this piece of software by donating some of your money to this project. Yeah, I realize that requesting money to develop software is a bit, well, capitalistic of me. But please realize that I live in a capitalistic society and I need money to have other people give me the things that I need to continue living under the rules of said society. So, if you feel that this piece of software has helped you out enough to warrant a reward, please PayPal a donation to now@disu.se¹. Thanks! Your support won’t go unnoticed! ¹ Send a donation: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=now@disu.se&item_name=Inventory-Rake § Reporting Bugs Please report any bugs that you encounter to the {issue tracker}¹. ¹ See https://github.com/now/inventory-rake/issues § Authors Nikolai Weibull wrote the code, the tests, the manual pages, and this README. § Licensing Inventory-Rake is free software: you may redistribute it and/or modify it under the terms of the {GNU Lesser General Public License, version 3}¹ or later², as published by the {Free Software Foundation}³. ¹ See http://disu.se/licenses/lgpl-3.0/ ² See http://gnu.org/licenses/ ³ See http://fsf.org/

the zaws gem provides command line tools for interfacing with AWS through the AWS CLI. It is required that the AWS CLI be installed on the system that this gem is used on. This gem expects the AWS credentials to be located in a location that the AWS CLI can access them, whether it be environment variables or config file.

Ironment populates environment variables with runcoms and executes commands.

Config as YAML yet still being 12-factor compliant, by serializing the file as one environment variable.

Simple feature flags based on a redis instance, a YAML config file and/or environment variables.

= sinatra-mongo Extends Sinatra with an extension method for dealing with monogodb using the ruby driver. Install it with gem: $ gem install sinatra-mongo Now we can use it an example application. require 'sinatra' require 'sinatra/mongo' # Specify the database to use. Defaults to mongo://localhost:27017/default, # so you will almost definitely want to change this. # # Alternatively, you can specify the MONGO_URL as an environment variable set :mongo, 'mongo://localhost:27017/sinatra-mongo-example' # At this point, you can access the Mongo::Database object using the 'mongo' helper: puts mongo["testCollection"].insert {"name" => "MongoDB", "type" => "database", "count" => 1, "info" => {"x" => 203, "y" => '102'}} get '/' do mongo["testCollection"].find_one end If you need to use authentication, you can specify this in the mongo uri: set :mongo, 'mongo://myuser:mypass@localhost:27017/sinatra-mongo-example' == Mongo Reference * http://www.mongodb.org/display/DOCS/Ruby+Tutorial == Note on Patches/Pull Requests * Fork the project. * Make your feature addition or bug fix. * Add tests for it. This is important so I don't break it in a future version unintentionally. * Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull) * Send me a pull request. Bonus points for topic branches. == Copyright Copyright (c) 2009 Joshua Nichols. See LICENSE for details.

Manages keys using environment variables.

Decrypt environment variables encrypted with Amazon's KMS service

tfwrapper provides Rake tasks for working with Hashicorp Terraform 0.9+, ensuring proper initialization and passing in variables from the environment or Ruby, as well as optionally pushing some information to Consul. tfwrapper also attempts to detect and retry failed runs due to AWS throttling or access denied errors.

This script allows you to easily automate the downloading of the latest version of any sourceforge project (as stored up to 31/12/2006) from any of sourceforge server by having it parse the web pages for the project and extract the latest release. It supports connecting through a proxy if either the environment variable HTTP_PROXY or http_proxy is defined. Also, downloads can be resumed like wget, in case the download is abruptly terminated. If .md5 checksums are available, they will also be downloaded and verified using ruby's digest/md5.

Roll is a library manager for Ruby. Code repositories can be made visible to Ruby just by setting an environment variable. Rolls effectively trivializes Ruby package management.

Simple Constnt Configuration for Ruby. Allows you to define configuration CONSTANTS that take values from environment variables. With support for default values, required variables and type conversions.

It is said to be good practice when you configure your app with a .env file. This library will (1) scan your source code looking for requests for environment variables, (2) parse a .env file and the variables defined on the machine, and (3) generate source code file to compile into app.

Vagrant plugin that stores the host path to your project in the environment variable in the VM.

rack middleware for exposing Heroku environment variables

Set $EDITOR environment variable to your desired editor, add 'error-locator' gem to your gem file and add ' post '/error-locator' => ErrorLocator' to your routes.rb. Click on a stack trace line in the browser.

This gem provides heroku environment variables in your local development environment.

Enable tracing by setting the TRACE environment variable to a list of the names of trace classes you want to investigate. The enabled tracing is generated in a nested format, with significant support for exceptions and debugging.

Heroku Builder allows for straight forward configuration of your multi (or single) stage Heroku application as well as dead simple deployment. It uses a YAML configuration to manage a multi-environment configuration, including: configuration variables, resources, add-ons, and git based deployment.

BlockHead provides an interceptor that can be used to restrict emails sent from a Rails application to a specific set of domains. Just set two environment variables -- the whitelisted domains and a bucket to collect redirected emails.

# Configure NSQ consumers and producers based on Krakow from environment ## Environment variables - `NSQLOOKUPD_URLS` (default to `http://localhost:4161`) - `NSQD_TLS` (default to `false`) - `NSQD_HOSTS` (default to `localhost:4150`) - `NSQD_TLS_CERT` - `NSQD_TLS_KEY` - `NSQD_TLS_CACERT`

Fetch your environment variables. Raise errors or set defaults when a setting does not exist.

Build yaml file from OS environment variables

EasyConf is a gem for reading configurations either from yaml files or from environment variables. With this gem you don't worry about where were your configurations.

Load configuration from yaml and/or environment variables

Reset dynos, environment variables, deploys master git branch, and purges the database.

Run a command with environment variables from etcd