Comment s'identifier user_name dans Rails?

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 ...

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

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.

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>

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'; }

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.

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}"

 }

]

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>

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

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

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}

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.