The CircleCI CLI allows you to locally validate your config.yml and run some or all non-parallelized jobs locally:
To Validate the config:
$ circleci config validate
To Run a job:
$ circleci local execute --job JOB_NAME
To Run the workflow:
circleci local execute
To know more visit the CircleCi Docs
const is a lexical declaration
default expects a HoistableDeclaration, ClassDeclaration or AssignmentExpression
and thus, export default const someVariable is a SynthaxError
Discard the job with no attempts to retry, if the exception is raised. This is useful when the subject of the job, like an Active Record, is no longer available, and the job is thus no longer relevant.
You can also pass a block that'll be invoked. This block is yielded with the job instance as the first and the error instance as the second parameter.
Example: 1
class SearchIndexingJob < ActiveJob::Base
discard_on ActiveJob::DeserializationError
discard_on(CustomAppException) do |job, error|
ExceptionNotifier.caught(error)
end
def perform(record)
# Will raise ActiveJob::DeserializationError if the record can't be deserialized
# Might raise CustomAppException for something domain specific
end
end
Example: 2:
class UserNotFoundJob < ActiveJob::Base
discard_on ActiveRecord::RecordNotFound
def perform(user_id)
@user = User.find(user_id)
@user.do_some_thing
end
end
Rails provides a way to eager load relationships when fetching objects, the main idea is to avoid queries N+1, but, when isn't a good idea when to do it?
When rendering unique results that can not be cached, for example: table reports
Why? Most of the times you need to display related information
orders = Order.includes(:user, :line_items).completed
When you use fragment cache
Why? Eager load is executed before the rendering, regardless the final result is already cached or not. If using eager loading, it will always be executed, but when allowing queries n+1 that query will be executed once to fill the cache, and that's it
products = Product.includes(:categories, variants: [:price]).search(keywords)
Use product.id & updated_at to fill a fragment cache and fetch the data from database only when needed, no extra info needed such as variants, categories, prices, etc
Have you wondered how to test your Rails log messages?
Try this:
it "logs a message" do
allow(Rails.logger).to receive(:info)
expect(Rails.logger).to receive(:info).with("Someone read this post!")
visit root_path
expect(page).to have_content "Welcome to TIL"
end
Or this:
it "logs a message" do
allow(Rails.logger).to receive(:info)
visit root_path
expect(page).to have_content "Welcome to TIL"
expect(Rails.logger).to have_received(:info).with("Someone read this post!")
end
Given code like this:
records = Record.includes(:related).all # Eager-loads to prevent N+1 queries...
records.each do |record|
puts record.related.count # => ... but this produces N+1 queries anyway!
end
If you run this, you'll notice you get an N+1 queries problem, even though we're using #includes. This happens because of record.related.count. Remember, records.related here is not an Array but an instance of CollectionProxy and its #count method always reaches out to the database. Use #length or #size instead to solve this issue.
records = Record.includes(:related).all
records.each do |record|
puts record.related.length # Problem solved!
end
Seems like something I need to learn every few years, and recently popped up on one of my side projects. If you're relying on email addresses as lookup keys, for instance in authentication/login scenarios, then standardize on lowercase and strip whitespace for good measure.
This came up when a customer was not able to get inbound email processing to work for his account. Turns out that his user record had a properly downcased email, but his SMTP server was sending his email address with capitalization. Some string massaging fixed the immediate issue.
User.find_by(email: reply_params["sender"].to_s.downcase)
After putting this fix in, I found everywhere else in the system that email addresses come in as input and gave them the same treatment.
Disclaimer: I know it's not recommended to do data mutation in schema migrations. But if you want to do it anyway, here's how you do a one-way operation, using the reversible method.
class AddAds < ActiveRecord::Migration[5.0]
def change
create_table :ads do |t|
t.string :image_url, null: false
t.string :link_url, null: false
t.integer :clicks, null: false, default: 0
t.timestamps
end
reversible do |change|
change.up do
Ad.create(image_url: "https://www.dropbox.com/s/9kevwegmvj53whd/973983_AdforCodeReview_v3_0211021_C02_021121.png?dl=1", link_url: "http://pages.magmalabs.io/on-demand-github-code-reviews-for-your-pull-requests")
end
end
end
end
Customer experience has never been more critical. Consumers crave enjoyable experiences with brands that are memorable. User-generated content (UGC) ticks all the boxes when it comes to connective content:
It builds and strengthens communities
It’s relatable and uplifting
It enables brands to meet customers where they’re already hanging out
It helps brands generate tons more content against a backdrop of stay-at-home orders and restrictive measures
UGC will be a common theme in 2021 as a significant content resource.
1) Install Lottie Player:
npm install --save @lottiefiles/lottie-player
2) Require it at app/javascript/packs/application.js
require('@lottiefiles/lottie-player');
3) Set webpacker to load jsons at config/webpacker.yml
static_asset_extensions:
- .json
4) Put your lotties jsons wherever you want e.g. app/javascript/images/lotties
5) Render lottie-player tag in your htm
%lottie-player{ autoplay: true,
loop: true,
src: asset_pack_path('media/images/lotties/mylottie.json') }
6) Profit
From the rails console try next:
irb(main):001:0> period_of_time = 10.minutes
=> 10 minutes
irb(main):002:0> period_of_time.class
=> ActiveSupport::Duration
irb(main):003:0> period_of_time = 10.hours
=> 10 hours
irb(main):004:0> period_of_time.class
=> ActiveSupport::Duration
irb(main):005:0> period_of_time.to_i
=> 36000
Useful when you work with devise authentication gem, e.g to expire the session in a certain period of time.
class User < ApplicationRecord
devise :database_authenticatable, :timeoutable,
timeout_in: ENV['EXPIRATION_TIME_IN_MINUTES'].to_i.minutes || 10.minutes
end
And so on...
User.where(created_at: 20.days.ago..10.minutes.ago)
Separate list elements with commas but not the last one:
ul > li:not(:last-child)::after {
content: ",";
}
Source: AllThingsSmitty
<img src="http://bitsofco.de/broken.jpg" alt="Broken Image">
img {
font-family: 'Helvetica';
font-weight: 300;
line-height: 2;
text-align: center;
width: 100%;
height: auto;
display: block;
position: relative;
}
img:before {
content: "We're sorry, the image below is broken :(";
display: block;
margin-bottom: 10px;
}
img:after {
content: "\f1c5" " " attr(alt);
font-size: 16px;
font-family: FontAwesome;
color: rgb(100, 100, 100);
display: block;
position: absolute;
z-index: 2;
top: 0;
left: 0;
width: 100%;
height: 100%;
background-color: #fff;
}
See the Pen Styling Broken Images by Victor Velazquez (@vicmaster) on CodePen.
Original source: bitsofco.de
If you need to use Ruby to connect to Aws Iot Core, this is all you need:
require 'aws-sdk-iot'
require 'aws-sdk-secretsmanager'
require 'json'
require 'mqtt'
secrets_manager = Aws::SecretsManager::Client.new(
region: ENV["IOT_AWS_REGION"],
access_key_id: ENV["IOT_AWS_ACCESS_KEY"],
secret_access_key: ENV["IOT_AWS_SECRET_ACCESS_KEY"]
)
client = Aws::IoT::Client.new(
region: ENV["IOT_AWS_REGION"],
access_key_id: ENV["IOT_AWS_ACCESS_KEY"],
secret_access_key: ENV["IOT_AWS_SECRET_ACCESS_KEY"]
)
# Creates new ssl certificate
cert = client.create_keys_and_certificate(set_as_active: true)
# A policy named iot-mqtt needs to exist with permissions to publish and read
# any topic names
client.attach_policy(policy_name: "iot-mqtt", target: cert.certificate_arn)
# Stores the certificate in aws secrets manager
secrets_manager.create_secret(name: "iot_cert_pem", secret_string: cert.certificate_pem)
secrets_manager.create_secret(name: "iot_private_key", secret_string: cert.key_pair.private_key)
# Reads the certificate from aws secrets manager
cert_pem = secrets_manager.get_secret_value(secret_id: "iot_cert_pem").secret_string
private_key = secrets_manager.get_secret_value(secret_id: "iot_private_key").secret_string
# Connects to aws iot core endpoint using mqtts
mqtt_client = MQTT::Client.new(ENV["IOT_AWS_ENDPOINT"])
mqtt_client.cert = cert_pem
mqtt_client.key = private_key
mqtt_client.connect(MQTT::Client.generate_client_id("my-awesome-app-"))
# Publishes a message
message = { desired: { speed_limit: 35 } }
mqtt_client.publish("$aws/things/sensor_home/shadow/update", { state: message }.to_json)
# Listens to all accepted shadow updates
mqtt_client.get("$aws/things/+/shadow/+/accepted") do |topic, message|
payload = JSON.decode(message)
puts "Got #{topic}"
puts "With #{payload}"
end
If you are not sure what PG version your environment is using, execute this in the rails console:
ActiveRecord::Base.connection.select_value('SELECT version()')