Categories
No matching categories were found
YARD is a documentation generation tool for the Ruby programming language.
It enables the user to generate consistent, usable documentation that can be
exported to a number of formats very easily, and also supports extending for
custom Ruby constructs such as custom class level definitions.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
3.68
This pure Ruby library can read and write PNG images without depending on an external
image library, like RMagick. It tries to be memory efficient and reasonably fast.
It supports reading and writing all PNG variants that are defined in the specification,
with one limitation: only 8-bit color depth is supported. It supports all transparency,
interlacing and filtering options the PNG specifications allows. It can also read and
write textual metadata from PNG files. Low-level read/write access to PNG chunks is
also possible.
This library supports simple drawing on the image canvas and simple operations like
alpha composition and cropping. Finally, it can import from and export to RMagick for
interoperability.
Also, have a look at OilyPNG at https://github.com/wvanbergen/oily_png. OilyPNG is a
drop in mixin module that implements some of the ChunkyPNG algorithms in C, which
provides a massive speed boost to encoding and decoding.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
2.39
Export i18n translations and use them on JavaScript.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
2.3
Download an entire website from the Wayback Machine. Wayback Machine by Internet Archive (archive.org) is an awesome tool to view any website at any point of time but lacks an export feature. Wayback Machine Downloader brings exactly this.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
2.08
Export existing AWS resources to Terraform style (tf, tfstate)
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
# SecureDataBag / Knife Secure Bag
Knife Secure Bag provides a consistent interface to DataBagItem, EncryptedDataBagItem as well as the custom created SecureDataBagItem while also providing a few extra handy features to help in your DataBag workflows.
SecureDataBagItem, can not only manage your existing DataBagItems and EncryptedDataBagItems, but it also provides you with a DataBag type which enables you to selectively encrypt only some of the fields in your DataBag thus allowing you to be able to search for the remaining fields.
## Installation
To build and install the plugin add it your Gemfile or run:
```shell
gem install secure_data_bag
```
## Configuration
#### Knife Secure Bag
Defaults for the Knife command may be provided in your _knife.rb_ file.
```ruby
knife[:secure_data_bag][:encrypted_keys] = %w(
password
ssh_keys
ssh_ids
public_keys
private_keys
keys
secret
)
knife[:secure_data_bag][:secret_file] = "#{local_dir}/secret.pem"
knife[:secure_data_bag][:export_root] = "#{kitchen_dir}/data_bags"
knife[:secure_data_bag][:export_on_upload] = true
knife[:secure_data_bag][:defaults][:secrets][:export_format] = 'plain'
```
To break this up:
`knife[:secure_data_bag][:encrypted_keys] = []`
When Knife Secure Bag encrypts a hash with an _encryption format_ of *nested*, it will recursively walk through the hash from the bottom up and encrypt any key found within this array.
`knife[:secure_data_bag][:secret_file]`
When encryption is required, the shared secret found at this location will be loaded.
`knife[:secure_data_bag][:export_root]`
When exporting a data\_bag\_item, files will be created in below this root directory. Typically this would be the data\_bag folder located within your kitchen.
`knife[:secure_data_bag][:export_on_upload]`
When a data\_bag\_item is edited using `knife secure bag edit`, it may be automatically exported to the _export\_root_.
`knife[:secure_data_bag][:defaults][:secrets][:export_format]`
The configuration file additionally supports the _defaults_ hash which provides default values for all _command line arguments_ that one might use. Of all of them only the _export\_format_ key is likely to be of much use.
## Examples
#### Chef cookbook recipe
```ruby
metadata = {}
# Define the keys we wish to encrypt
metadata[:encrypted_keys] = %w(encoded)
# Optionally load a specific shared secret. Otherwise, the global
# encrypted\_data\_bag\_secret will be automatically used.
secret_key = SecureDataBagItem.load_key("/path/to/secret")
# Create a hash of data to use as an exampe
raw_data = {
id: "item",
data_bag: "data_bag",
encoded: "my string",
unencoded: "other string"
}
# Instantiate a SecureDataBagItem from a hash
item = SecureDataBagItem.from_hash(data, metadata)
# Or more explicitely
item = SecureDataBagItem.from_hash(data, encrypted_keys: %w(encoded))
# Or load from server
item = SecureDataBagItem.load("data_bag", "item")
# Print the un-encrypted raw data
pp item.raw_data
# Print the un-encrypted `encoded` key
pp item['encoded']
# Print the encrypted hash as a data_bag_item hash
pp item.to_hash
=begin
{
id: "item",
data_bag: "data_bag",
encoded: {
encrypted_data: "encoded",
cipher: aes-256-cbc,
iv: 13453453dkgfefg==
version: 1
}
unencoded: "other string",
}
=end
```
## Usage
#### Knife commands
Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as plain text.
```shell
knife secure bag show -F js secrets secret_item
```
Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as a SecureDataBagItem in encrypted format.
```shell
knife secure bag show -F js secrets secret_item --enc-format nested
```
Edit an EncryptedDataBagItem, preserve it's encryption type, and export a copy to the _data\_bag_ folder in your kitchen.
```shell
knife secure bag edit secrets secret_item --export
```
## Knife SubCommands
Most of the SubCommands support the following command-line options:
`--enc-format [plain,encrypted,nested]`
Ensure that, when displaying or uploading the data\_bag\_item, we forcibly encrypt the data\_bag\_item using the specified format instead of preserving the existing format.
In this case:
- plain: refers to a DataBagItem
- encrypted: refers to an EnrytpedDataBagItem
- nested: refers to a SecureDataBagItem
`--dec-format [plain,encrypted,nested]`
Attempt to decrypt the data\_bag\_item using the given format rather than the auto-detected one. The only real reason to use this is when you wish to specifically select _plain_ as the format so as to not decrypt the item.
`--enc-keys key1,key2,key3`
Provide a comma delimited list of hash keys which should be encrypted when encrypting the data\_bag\_item. This list will be concatenated with any key names listed in the configuration file or which were previously encrypted.
`--export`
Export the data\_bag\_item to json file in either of _export-format_ or _enc-format_.
`--export-format`
Overrides the encryption format only for the _export_ feature.
`--export-root`
Root directly under which a folder should exist for each _data_bag_ into which to export _data_bag_items_ as json files.
When displaying the content of the _data\_bag\_item_, an additional key of *_secure_metadata* will be added to the output which contains gem specific metadata such as the encryption formats and any encrypted keys found. This key will _not_ be saved with the item, however it may be manipulated to alter the behavior of the _edit_ or _export_ commands.
#### knife secure bag show DATA_BAG ITEM
This command functions just like `knife data bag show` and is used to print out the content of either a DataBagItem, EncryptedDataBagItem or SecureDataBagItem.
By default, it will auto-detect the Item type, and print it's unencrypted version to the terminal. This behavior, however, may be altered using the previously mentioned command line options.
#### knife secure bag open PATH
This commands functions much like `knife secure bag show`, however it is designed to load a _data\_bag\_item_ from disk as opposed to loading it from Chef server. This may be of use when view the content of an exported encrypted file.
#### knife secure bag edit DATA_BAG DATA_BAG_ITEM
This command functions just like `knife data bag edit` and is used to edit either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`.
#### knife secure bag from file DATA_BAG PATH
This command functions just like `knife data bag from file` and is used to upload either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`.
## Recipe DSL
The gem additionally provides a few Recipe DSL methods which may be useful.
```ruby
load_secure_item = secure_data_bag_item(
data_bag_name,
data_bag_item,
cache: false
)
load_plain_item = data_bag_item(data_bag_name, data_bag_item)
convert_plain_to_secure = secure_data_bag_item!(load_plain_item)
```
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
1.15
The Cloud Logging API lets you programmatically read and write log entries, set up exclusions, create logs-based metrics, and manage export sinks. Note that google-cloud-logging-v2 is a version-specific client library. For most uses, we recommend installing the main client library google-cloud-logging instead. See the readme for more details.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
MakeExportable is a Rails gem/plugin to assist in exporting application data as CSV, TSV, JSON, HTML, XML or Excel. Filter and limit the data exported using ActiveRecord. Export returned values from instance methods as easily as database columns.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.01
This exporter has been deprecated. To export your OTLP traces from OpenTelemetry
SDK directly to Datadog Agent, please refer to OTLP Ingest in Datadog Agent:
https://docs.datadoghq.com/tracing/setup_overview/open_standards/#otlp-ingest-in-datadog-agent.
opentelemetry-exporters-datadog is Datadog’s trace exporter for the OpenTelemetry
Ruby tracing library, which is used to trace requests across web servers, databases
and microservices. The exporter formats and sends these traces to a Datadog Agent so
that they can be ingested, stored, and analyzed with Datadog.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.66
OTLP exporter for the OpenTelemetry framework
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.64
Prometheus metric collector and exporter for Ruby
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.01
Enhanced version of exporting and importing your Radiant database tables to/from YAML files
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
0.0
Given a compatible export model, this gem exports the data into the specified format
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
0.46
Jaeger trace exporter for the OpenTelemetry framework
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.06
Program to export GitHub, GitLab, or Bitbucket pull requests/merge requests and issues to CSV a file.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
ExportCsv is a small library intended to simplify the common steps involved with export table data to CSV files. ExportCsv is compatible with recent 1.8 versions of Ruby as well as Ruby 1.9+
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
0.57
Quick way to inspect your Rails database, see content of tables, filter, export them to CSV, Excel, EXPLAIN SQL and run SQL queries.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
create csv exports from the sqlite export and the export_version json
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.01
Exportable will help you in exporting ActiveRecord models in to different output formats including CSV, XLS etc.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
Export ActiveModels to CSV by declaring headers and fields in your model with the `exportable` class method and block.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity