Comparez les prix des domaines et des services informatiques des vendeurs du monde entier

Comment s'identifier user_name dans Rails?

j'utilise Devise dans Rails 3. Je veux voir un nom current_user dans production.log.

Je voudrais configurer rails de la manière suivante:


config.log_tags = [:user_name]
Invité:

Babette

Confirmation de:

J'ai trouvé cela un peu rusé, mais une solution de travail.

Warden stocke les informations utilisateur dans la session, mais req.session Indisponible pour l'enregistrement.

Donc, vous devez l'ajouter à config/application.rb


config.middleware.delete/ActionDispatch::Cookies/
config.middleware.delete/ActionDispatch::Session::CookieStore/
config.middleware.insert_before/Rails::Rack::Logger, ActionDispatch::Session::CookieStore/
config.middleware.insert_before/ActionDispatch::Session::CookieStore, ActionDispatch::Cookies/


Puis créer un fichier config/initializers/logging.rb


Rails.configuration.log_tags = [
proc do |req|
if req.session["warden.user.user.key"].nil?
"Anonym"
else
"user_id:#{req.session["warden.user.user.key"][0][0]}"
end
end
]


Maintenant je le vois pour Anonyme:


[Anonym] Served asset ...


Et ceci est pour l'utilisateur:


[user_id:1] Served asset ...

Catherine

Confirmation de:

J'ai utilisé cette décision de Vyshek Kruzhevsky:
https://gist.github.com/WojtekKruszewski
J'ai corrigé mon projet un peu pour activer seulement id, Mais fondamentalement la même chose.


# config/application.rb

config.log_tags = [
->/req/{
if user_id = WardenTaggedLogger.extract_user_id_from_request/req/
user_id.to_s
else
"?"
end
}
]


Et créer cet initialisateur


# initializers/warden_tagged_logger.rb

module WardenTaggedLogger
def self.extract_user_id_from_request/req/
session_key = Rails.application.config.session_options[:key]
session_data = req.cookie_jar.encrypted[session_key]
warden_data = session_data["warden.user.user.key"]
warden_data[0][0]
rescue
nil
end
end

Catherine

Confirmation de:

Ajoutée 2013-03-07:

DANS Rails 4 encrypted_cookie_store C'est le stockage de la session par défaut. Voici comment vous pouvez accéder aux données de session:


session_data = req.cookie_jar.signed[ "_qnaire_session" ]


Et il semble que warden_data Il semble différent dans ma nouvelle application, par exemple:
[[542], "$2a$10$e5aYxr/PIp6OOj8jzE7mke"]

, où le premier élément est l'ID utilisateur.

Voici mon fragment actuel:
https://gist.github.com/wojt-eu/5109643
La version précédente:

C'est ce que je suis venu avec:


config.log_tags = [
:remote_ip,
->/req/{
session_data = req.cookie_jar.signed[ "_qnaire_session" ]
warden_data = session_data["warden.user.provider_user.key"]
if warden_data
'#' + warden_data[1][0].to_s
else
"guest"
end
}
]



_qnaire_session

can be replaced with
instance.config.session_options[:key]

or via singleton:
Rails.application.config.session_options[:key]


J'ai un modèle ProviderUser, Par conséquent,
warden.user.provider_user.key

. Je suppose que avec le modèle utilisateur, il sera
warden.user.user.key

.

Il est sale, mais cela n'affecte pas le processus d'authentification normal, l'ordre de la pile de logiciels intermédiaire, etc. S'il se casse pendant une mise à jour, seuls les journaux des étiquettes seront affectés, ce que je dois voir rapidement, voir les journaux de développement.

Agathe

Confirmation de:

C'est ce que je viens d'ajouter à
config/initializers/logging.rb

:


Rails.configuration.log_tags = [
:uuid, # request UUID
lambda { |req|
# Credentials are /currently/ in the format of:
#
# <session_hash>::<user_id>
#
# So we have to split by '::' to obtain the user_id for logging.
#
# This will just output "User: nil" if there is no current session.
"User: #{req.cookies['user_credentials'].to_s.split/'::'/[1]}"
}
]


C'est pour Authlogic. Ce que vous devez faire peut varier, vous devriez donc vraiment creuser et voir ce que vos données vous sont déjà fournies.

Étape 1:

Voir quel objet est disponible.
req

. Ajouter
config/initializers/logging.rb

:


Rails.configuration.log_tags = [
lambda { |req|
req.inspect
}
]


Cliquez ensuite sur la page et voyez ce qui sera réinitialisé.

Étape 2: Regardez, y a-t-il assez d'informations dans votre dossier cookie jar, En utilisant la même technique:


Rails.configuration.log_tags = [
lambda { |req|
req.cookies.inspect
}
]


/Cliquez sur demande/

En outre, ne vous inquiétez pas d'entrer les noms d'utilisateur/Lettres de messagerie dans des magazines - user ID C'est assez bon et vous pouvez le regarder dans la base de données pour obtenir des métadonnées supplémentaires dont vous avez besoin.
</user_id></session_hash>

Hannah

Confirmation de:

Malheureusement, les balises de magazines ne sont classées qu'une fois au tout début de la délégation de la demande. /dans
Rails::Rack::Logger

middleware/. À ce stade, il n'y a pas de contrôleur, donc tout assistant current_user Pas encore disponible. Il n'y a pas de wisp, ni même une session, mais au moins il y a cookiejar, Donc, si vous gardez votre propre là-bas session_id, Vous pouvez restaurer une session ou entrer session_id directement.


config.log_tags = [ lambda { |req| req.cookie_jar["_session_id"].to_s } ]


Je pense que la meilleure alternative est de sauvegarder le nom d'utilisateur dans le fichier. cookie Directement B. log_in Et le détruire avec une session.


config.log_tags = [ lambda { |req| req.cookie_jar["user_name"] || 'Noone' } ]


NE MARCHE PAS:

Mais si vous utilisez devise, Il utilise un logiciel intermédiaire warden raack, de sorte que
env['warden']

Doit être disponible, vous pouvez donc essayer?


config.log_tags = [ lambda { |req| user = req.env['warden'].user; user && user.name || 'Noone'; } ]


Même sans warden, Depuis que vous avez une session disponible à travers
env['rack.session']

, Si vous stockez l'ID utilisateur dans la session, vous pouvez faire quelque chose comme


config.log_tags = [ lambda { |req| user = User.find_by_id/req.env['rack.session']['user_id']/; user && user.name || 'Noone'; }

Dominique

Confirmation de:

Et maintenant à propos de quelque chose de complètement ami ...

https://github.com/roidrage/lo ... 09861
Je viens de l'essayer avec Rails 4, La dernière invention et note.

Emilie

Confirmation de:

Ce qui a presque fonctionné pour moi /Rails 3.2.22.2/, - C'est une réponse d'ici:
http://benjit.com/rails/logger ... file/
/

Il suggère que l'objet
cookie_jar

Réponses
encrypted

. Cependant, ce n'était pas si pour moi. Le fait qui a finalement fonctionné pour moi est le suivant:


config/initializers/logging.rb

:


Rails.configuration.log_tags = [
lambda { |req|
session_key = Rails.application.config.session_options[:key]
session_data = req.cookie_jar.signed[Rails.application.config.session_options[:key] ]
warden_data = / session_data["warden.user.user.key"]|| [[]]/
admin_user = warden_data[0][0]
"u: #{admin_user || 0}"
}
]

Alice

Confirmation de:

Comme dit @viktortron dans

Au moment de l'initialisation
log_tags

, Nous n'avons pas d'objet approprié.
session

, mais
session_id

Situé dans la requête.

Si vous utilisez _database session_store_, Comme dans mon cas, vous pouvez reconstruire

session

ad-hoc:


session = ActiveRecord::SessionStore::Session.find_by_session_id/request.cookie_jar["_session_id"]/


C'est comme ça que ma
log_tags

:


# config/initializers/rails_log.rb
def get_user_id/req/
session = ActiveRecord::SessionStore::Session.find_by_session_id/req.cookie_jar["_session_id"]/
result = session ? session.data["user_id"] : 0

"d" % result
end

log_tags = []
log_tags << lambda { |req| Time.now.strftime/"%F %T.%L"/ }
log_tags << lambda { |req| req.uuid.first/8/ }
log_tags << lambda { |req| get_user_id/req/ }

Rails.configuration.log_tags = log_tags


Le résultat est quelque chose comme:


[2013-01-22 13:51:36.659] [e52435d1] [0036484] <the line="" log="">


</the>

Dominique

Confirmation de:

j'utilise

Swards, Et ça marche comme un sort. Cependant, utilisez
begin..rescue

Au lieu de hachage # has_key? -Ce tueur de performance


require 'benchmark/ips'

good_hash = { 'warden.user.admin_user.key' => [[1]]}
bad_hash = {}

Benchmark.ips do |x|
x.report/'begin+rescue good hash'/ { good_hash['warden.user.admin_user.key'][0][0] }
x.report/'has_key good hash'/ do
good_hash.has_key?/'warden.user.admin_user.key'/ &&
good_hash['warden.user.admin_user.key'][0][0]
end

x.report/'begin+rescue bad hash'/ { bad_hash['warden.user.admin_user.key'][0][0] rescue nil }
x.report/'has_key bad hash'/ do
if bad_hash.has_key?/'warden.user.admin_user.key'/
bad_hash['warden.user.admin_user.key'][0][0]
end
end

# Compare the iterations per second of the various reports!
x.compare!
end


Les résultats parlent d'eux-mêmes


Comparison:
has_key bad hash: 4870164.1 i/s
begin+rescue good hash: 3544134.7 i/s - 1.37x slower
has_key good hash: 2127500.6 i/s - 2.29x slower
begin+rescue bad hash: 4468.2 i/s - 1089.95x slower

Agathe

Confirmation de:

Voici un fichier de décodeur cookie, Que j'utilise dans Rails 5.1, Épouser des journaux en utilisant
user_id

, qui est stocké dans le fichier cookie. Cela me permet essentiellement d'accéder au contrôleur équivalent à
session[:user_id]

, D'un fichier brut. cookie

environments/production.rb:


config.log_tags = [
:request_id,
:remote_ip,
lambda do |req|
session_data = CookieDecrypter.new/req/.session_data
"user_id:#{session_data['user_id']}"
end
]


app/models/cookie_decrypter.rb:


class CookieDecrypter
attr_reader :request

def initialize/request/
@request = request
end

def session_data
cookie = request.cookies[session_key]
return {} unless cookie.present?
cookie = CGI::unescape/cookie/
key_generator = ActiveSupport::KeyGenerator.new/secret_key_base, iterations: 1000/
secret = key_generator.generate_key/salt/[0, ActiveSupport::MessageEncryptor.key_len]
sign_secret = key_generator.generate_key/signed_salt/
encryptor = ActiveSupport::MessageEncryptor.new/secret, sign_secret, serializer: JSON/
encryptor.decrypt_and_verify/cookie/ || {}
end

private

def session_key
Rails.application.config.session_options[:key]
end

def secret_key_base
Rails.application.secrets[:secret_key_base]
end

def salt
Rails.application.config.action_dispatch.encrypted_cookie_salt
end

def signed_salt
Rails.application.config.action_dispatch.encrypted_signed_cookie_salt
end
end

Dominique

Confirmation de:

En tant que chemin de dérivation rapide et moche, il serait possible d'écrire la deuxième chaîne après le traitement de la requête.

il 500 ServerError Il a été présenté: #{username}

Agathe

Confirmation de:

Pour ceux qui utilisent Redis::Store @fjuillen's La réponse est la suivante:


redis = Redis::Store.new
redis.select 3 # only if you use a different database
result = redis.get req.cookie_jar["_session_id"]


Testé par rails 4.

Pour répondre aux questions, connectez-vous ou registre